comparing be0b2c78d45df58e35bed899be2c70dc8c5b1c7b and main on comet.sh/atex

+10

.credo.exs

···

       1
       1
       +
       %{

     

       2
       2
       +
         configs: [

     

       3
       3
       +
           %{

     

       4
       4
       +
             name: "default",

     

       5
       5
       +
             checks: %{

     

       6
       6
       +
               disabled: [{Credo.Check.Design.TagTODO, []}]

     

       7
       7
       +
             }

     

       8
       8
       +
           }

     

       9
       9
       +
         ]

     

       10
       10
       +
       }

+5 -2

.formatter.exs

···

       1
       1
        
       # Used by "mix format"

     

       2
       2
        
       [

     

       3
       3
       -
         inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"],

     

       4
       4
       -
         import_deps: [:typedstruct]

     

       3
       3
       +
         inputs: ["{mix,.formatter,.credo}.exs", "{config,examples,lib,test}/**/*.{ex,exs}"],

     

       4
       4
       +
         import_deps: [:typedstruct, :peri, :plug],

     

       5
       5
       +
         export: [

     

       6
       6
       +
           locals_without_parens: [deflexicon: 1]

     

       7
       7
       +
         ]

     

       5
       8
        
       ]

+21

.github/workflows/push.yaml

···

       1
       1
       +
       name: Push

     

       2
       2
       +
       on:

     

       3
       3
       +
         push:

     

       4
       4
       +
           branches:

     

       5
       5
       +
             - main

     

       6
       6
       +
       

     

       7
       7
       +
       jobs:

     

       8
       8
       +
         docker:

     

       9
       9
       +
           name: Lint and test

     

       10
       10
       +
           runs-on: ubuntu-latest

     

       11
       11
       +
       

     

       12
       12
       +
           steps:

     

       13
       13
       +
             - uses: actions/checkout@v4

     

       14
       14
       +
       

     

       15
       15
       +
             - name: Install Nix

     

       16
       16
       +
               uses: nixbuild/nix-quick-install-action@v30

     

       17
       17
       +
       

     

       18
       18
       +
             - run: nix flake check

     

       19
       19
       +
             - run: nix develop --command mix deps.get

     

       20
       20
       +
             - run: nix develop --command mix credo --mute-exit-status -a

     

       21
       21
       +
             - run: nix develop --command mix test

+9 -16

.gitignore

···

       1
       1
       -
       # The directory Mix will write compiled artifacts to.

     

       2
       1
        
       /_build/

     

       3
       3
       -
       

     

       4
       4
       -
       # If you run "mix test --cover", coverage assets end up here.

     

       5
       2
        
       /cover/

     

       6
       6
       -
       

     

       7
       7
       -
       # The directory Mix downloads your dependencies sources to.

     

       8
       3
        
       /deps/

     

       9
       9
       -
       

     

       10
       10
       -
       # Where third-party dependencies like ExDoc output generated docs.

     

       11
       4
        
       /doc/

     

       12
       12
       -
       

     

       13
       13
       -
       # If the VM crashes, it generates a dump, let's ignore it too.

     

       14
       5
        
       erl_crash.dump

     

       15
       15
       -
       

     

       16
       16
       -
       # Also ignore archive artifacts (built via "mix archive.build").

     

       17
       6
        
       *.ez

     

       18
       18
       -
       

     

       19
       19
       -
       # Ignore package tarball (built via "mix hex.build").

     

       20
       7
        
       atex-*.tar

     

       21
       21
       -
       

     

       22
       22
       -
       # Temporary files, for example, from tests.

     

       23
       8
        
       /tmp/

     

       24
       9
        
       

     

       25
       10
        
       .envrc

     

       26
       26
       -
       .direnv
     

       11
       11
       +
       .direnv

     

       12
       12
       +
       .vscode/

     

       13
       13
       +
       .elixir_ls

     

       14
       14
       +
       lexicons

     

       15
       15
       +
       secrets

     

       16
       16
       +
       .DS_Store

     

       17
       17
       +
       CLAUDE.md

     

       18
       18
       +
       tmp

     

       19
       19
       +
       temp

.vscode/settings.json

This is a binary file and will not be displayed.

+89

CHANGELOG.md

···

       1
       1
       +
       # Changelog

     

       2
       2
       +
       

     

       3
       3
       +
       All notable changes to atex will be documented in this file.

     

       4
       4
       +
       

     

       5
       5
       +
       The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),

     

       6
       6
       +
       and this project adheres to

     

       7
       7
       +
       [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

     

       8
       8
       +
       

     

       9
       9
       +
       <!-- ## [Unreleased] -->

     

       10
       10
       +
       

     

       11
       11
       +
       ## [0.6.0] - 2025-11-25

     

       12
       12
       +
       

     

       13
       13
       +
       ### Breaking Changes

     

       14
       14
       +
       

     

       15
       15
       +
       - `deflexicon` now converts all def names to be in snake_case instead of the

     

       16
       16
       +
         casing as written the lexicon.

     

       17
       17
       +
       

     

       18
       18
       +
       ### Added

     

       19
       19
       +
       

     

       20
       20
       +
       - `deflexicon` now emits structs for records, objects, queries, and procedures.

     

       21
       21
       +
       - `Atex.XRPC.get/3` and `Atex.XRPC.post/3` now support having a lexicon struct

     

       22
       22
       +
         as the second argument instead of the method's name, making it easier to have

     

       23
       23
       +
         properly checked XRPC calls.

     

       24
       24
       +
       - Add pre-transpiled modules for the core `com.atproto` lexicons.

     

       25
       25
       +
       

     

       26
       26
       +
       ## [0.5.0] - 2025-10-11

     

       27
       27
       +
       

     

       28
       28
       +
       ### Breaking Changes

     

       29
       29
       +
       

     

       30
       30
       +
       - Remove `Atex.HTTP` and associated modules as the abstraction caused a bit too

     

       31
       31
       +
         much complexities for how early atex is. It may come back in the future as

     

       32
       32
       +
         something more fleshed out once we're more stable.

     

       33
       33
       +
       - Rename `Atex.XRPC.Client` to `Atex.XRPC.LoginClient`

     

       34
       34
       +
       

     

       35
       35
       +
       ### Added

     

       36
       36
       +
       

     

       37
       37
       +
       - `Atex.OAuth` module with utilites for handling some OAuth functionality.

     

       38
       38
       +
       - `Atex.OAuth.Plug` module (if Plug is loaded) which provides a basic but

     

       39
       39
       +
         complete OAuth flow, including storing the tokens in `Plug.Session`.

     

       40
       40
       +
       - `Atex.XRPC.Client` behaviour for implementing custom client variants.

     

       41
       41
       +
       - `Atex.XRPC` now supports using different client implementations.

     

       42
       42
       +
       - `Atex.XRPC.OAuthClient` to make XRPC calls on the behalf of a user who has

     

       43
       43
       +
         authenticated with ATProto OAuth.

     

       44
       44
       +
       

     

       45
       45
       +
       ## [0.4.0] - 2025-08-27

     

       46
       46
       +
       

     

       47
       47
       +
       ### Added

     

       48
       48
       +
       

     

       49
       49
       +
       - `Atex.Lexicon` module that provides the `deflexicon` macro, taking in a JSON

     

       50
       50
       +
         Lexicon definition and converts it into a series of schemas for each

     

       51
       51
       +
         definition within it.

     

       52
       52
       +
       - `mix atex.lexicons` for converting lexicon JSON files into modules using

     

       53
       53
       +
         `deflexicon` easily.

     

       54
       54
       +
       

     

       55
       55
       +
       ## [0.3.0] - 2025-06-29

     

       56
       56
       +
       

     

       57
       57
       +
       ### Changed

     

       58
       58
       +
       

     

       59
       59
       +
       - `Atex.XRPC.Adapter` renamed to `Atex.HTTP.Adapter`.

     

       60
       60
       +
       

     

       61
       61
       +
       ### Added

     

       62
       62
       +
       

     

       63
       63
       +
       - `Atex.HTTP` module that delegates to the currently configured adapter.

     

       64
       64
       +
       - `Atex.HTTP.Response` struct to be returned by `Atex.HTTP.Adapter`.

     

       65
       65
       +
       - `Atex.IdentityResolver` module for resolving and validating an identity,

     

       66
       66
       +
         either by DID or a handle.

     

       67
       67
       +
         - Also has a pluggable cache (with a default ETS implementation) for keeping

     

       68
       68
       +
           some data locally.

     

       69
       69
       +
       

     

       70
       70
       +
       ## [0.2.0] - 2025-06-09

     

       71
       71
       +
       

     

       72
       72
       +
       ### Added

     

       73
       73
       +
       

     

       74
       74
       +
       - `Atex.TID` module for manipulating ATProto TIDs.

     

       75
       75
       +
       - `Atex.Base32Sortable` module for encoding/decoding numbers as

     

       76
       76
       +
         `base32-sortable` strings.

     

       77
       77
       +
       - Basic XRPC client.

     

       78
       78
       +
       

     

       79
       79
       +
       ## [0.1.0] - 2025-06-07

     

       80
       80
       +
       

     

       81
       81
       +
       Initial release.

     

       82
       82
       +
       

     

       83
       83
       +
       [unreleased]: https://github.com/cometsh/atex/compare/v0.6.0...HEAD

     

       84
       84
       +
       [0.6.0]: https://github.com/cometsh/atex/releases/tag/v0.6.0

     

       85
       85
       +
       [0.5.0]: https://github.com/cometsh/atex/releases/tag/v0.5.0

     

       86
       86
       +
       [0.4.0]: https://github.com/cometsh/atex/releases/tag/v0.4.0

     

       87
       87
       +
       [0.3.0]: https://github.com/cometsh/atex/releases/tag/v0.3.0

     

       88
       88
       +
       [0.2.0]: https://github.com/cometsh/atex/releases/tag/v0.2.0

     

       89
       89
       +
       [0.1.0]: https://github.com/cometsh/atex/releases/tag/v0.1.0

+10 -7

README.md

···

       6
       6
        
       ## Current Roadmap (in no particular order)

     

       7
       7
        
       

     

       8
       8
        
       - [x] `at://` parsing and struct

     

       9
       9
       -
       - [ ] XRPC client

     

       10
       10
       -
       - [ ] CID & TID codecs

     

       11
       11
       -
       - [ ] DID & handle resolution service with a cache

     

       12
       12
       -
       - [ ] Structs with validation for the common lexicons

     

       13
       13
       -
         - [ ] Probably codegen for doing this with other lexicons

     

       14
       14
       -
       - [ ] Oauth stuff

     

       9
       9
       +
       - [x] TID codecs

     

       10
       10
       +
       - [x] XRPC client

     

       11
       11
       +
       - [x] DID & handle resolution service with a cache

     

       12
       12
       +
       - [x] Macro for converting a Lexicon definition into a runtime-validation schema

     

       13
       13
       +
         - [x] Codegen to convert a directory of lexicons

     

       14
       14
       +
       - [x] Oauth stuff

     

       15
       15
       +
       - [x] Extended XRPC client with support for validated inputs/outputs

     

       16
       16
       +
       - [ ] Proper MST & CAR handling things

     

       17
       17
       +
       - [ ] Pre-transpiled libraries for popular lexicons

     

       15
       18
        
       

     

       16
       19
        
       ## Installation

     

       17
       20
        
       

     
···

       20
       23
        
       ```elixir

     

       21
       24
        
       def deps do

     

       22
       25
        
         [

     

       23
       23
       -
           {:atex, "~> 0.1"}

     

       26
       26
       +
           {:atex, "~> 0.6"}

     

       24
       27
        
         ]

     

       25
       28
        
       end

     

       26
       29
        
       ```

+11

bump_builtin_lexicons.sh

···

       1
       1
       +
       #!/usr/bin/env bash

     

       2
       2
       +
       

     

       3
       3
       +
       set -euo pipefail

     

       4
       4
       +
       

     

       5
       5
       +
       SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

     

       6
       6
       +
       cd "$SCRIPT_DIR"

     

       7
       7
       +
       

     

       8
       8
       +
       mkdir -p ./tmp

     

       9
       9
       +
       git clone --depth 1 --single-branch https://github.com/bluesky-social/atproto.git ./tmp/atproto

     

       10
       10
       +
       mix atex.lexicons ./tmp/atproto/lexicons/com/atproto/**/*.json

     

       11
       11
       +
       rm -rf ./tmp

+10

config/runtime.exs

···

       1
       1
       +
       import Config

     

       2
       2
       +
       

     

       3
       3
       +
       config :atex, Atex.OAuth,

     

       4
       4
       +
         # base_url: "https://comet.sh/aaaa",

     

       5
       5
       +
         base_url: "http://127.0.0.1:4000/oauth",

     

       6
       6
       +
         is_localhost: true,

     

       7
       7
       +
         scopes: ~w(transition:generic),

     

       8
       8
       +
         private_key:

     

       9
       9
       +
           "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgyIpxhuDm0i3mPkrk6UdX4Sd9Jsv6YtAmSTza+A2nArShRANCAAQLF1GLueOBZOVnKWfrcnoDOO9NSRqH2utmfGMz+Rce18MDB7Z6CwFWjEq2UFYNBI4MI5cMI0+m+UYAmj4OZm+m",

     

       10
       10
       +
         key_id: "awooga"

+60

examples/oauth.ex

···

       1
       1
       +
       defmodule ExampleOAuthPlug do

     

       2
       2
       +
         use Plug.Router

     

       3
       3
       +
         alias Atex.OAuth

     

       4
       4
       +
         alias Atex.XRPC

     

       5
       5
       +
       

     

       6
       6
       +
         plug :put_secret_key_base

     

       7
       7
       +
       

     

       8
       8
       +
         plug Plug.Session,

     

       9
       9
       +
           store: :cookie,

     

       10
       10
       +
           key: "atex-oauth",

     

       11
       11
       +
           signing_salt: "signing-salt"

     

       12
       12
       +
       

     

       13
       13
       +
         plug :match

     

       14
       14
       +
         plug :dispatch

     

       15
       15
       +
       

     

       16
       16
       +
         forward "/oauth", to: Atex.OAuth.Plug

     

       17
       17
       +
       

     

       18
       18
       +
         get "/whoami" do

     

       19
       19
       +
           conn = fetch_session(conn)

     

       20
       20
       +
       

     

       21
       21
       +
           with {:ok, client} <- XRPC.OAuthClient.from_conn(conn),

     

       22
       22
       +
                {:ok, response, client} <-

     

       23
       23
       +
                  XRPC.post(client, %Com.Atproto.Repo.CreateRecord{

     

       24
       24
       +
                    input: %Com.Atproto.Repo.CreateRecord.Input{

     

       25
       25
       +
                      repo: client.did,

     

       26
       26
       +
                      collection: "app.bsky.feed.post",

     

       27
       27
       +
                      rkey: Atex.TID.now() |> to_string(),

     

       28
       28
       +
                      record: %App.Bsky.Feed.Post{

     

       29
       29
       +
                        text: "Hello world from atex!",

     

       30
       30
       +
                        createdAt: NaiveDateTime.to_iso8601(NaiveDateTime.utc_now())

     

       31
       31
       +
                      }

     

       32
       32
       +
                    }

     

       33
       33
       +
                  }) do

     

       34
       34
       +
             IO.inspect(response, label: "output")

     

       35
       35
       +
       

     

       36
       36
       +
             conn

     

       37
       37
       +
             |> XRPC.OAuthClient.update_plug(client)

     

       38
       38
       +
             |> send_resp(200, response.uri)

     

       39
       39
       +
           else

     

       40
       40
       +
             :error ->

     

       41
       41
       +
               send_resp(conn, 401, "Unauthorized")

     

       42
       42
       +
       

     

       43
       43
       +
             err ->

     

       44
       44
       +
               IO.inspect(err, label: "xrpc failed")

     

       45
       45
       +
               send_resp(conn, 500, "xrpc failed")

     

       46
       46
       +
           end

     

       47
       47
       +
         end

     

       48
       48
       +
       

     

       49
       49
       +
         match _ do

     

       50
       50
       +
           send_resp(conn, 404, "oops")

     

       51
       51
       +
         end

     

       52
       52
       +
       

     

       53
       53
       +
         def put_secret_key_base(conn, _) do

     

       54
       54
       +
           put_in(

     

       55
       55
       +
             conn.secret_key_base,

     

       56
       56
       +
             # Don't use this in production

     

       57
       57
       +
             "5ef1078e1617463a3eb3feb9b152e76587a75a6809e0485a125b6bb7ae468f086680771f700d77ff61dfdc8d8ee8a5c7848024a41cf5ad4b6eb3115f74ce6e46"

     

       58
       58
       +
           )

     

       59
       59
       +
         end

     

       60
       60
       +
       end

+3 -3

flake.lock

···

       2
       2
        
         "nodes": {

     

       3
       3
        
           "nixpkgs": {

     

       4
       4
        
             "locked": {

     

       5
       5
       -
               "lastModified": 1749143949,

     

       6
       6
       -
               "narHash": "sha256-QuUtALJpVrPnPeozlUG/y+oIMSLdptHxb3GK6cpSVhA=",

     

       5
       5
       +
               "lastModified": 1755615617,

     

       6
       6
       +
               "narHash": "sha256-HMwfAJBdrr8wXAkbGhtcby1zGFvs+StOp19xNsbqdOg=",

     

       7
       7
        
               "owner": "nixos",

     

       8
       8
        
               "repo": "nixpkgs",

     

       9
       9
       -
               "rev": "d3d2d80a2191a73d1e86456a751b83aa13085d7d",

     

       9
       9
       +
               "rev": "20075955deac2583bb12f07151c2df830ef346b4",

     

       10
       10
        
               "type": "github"

     

       11
       11
        
             },

     

       12
       12
        
             "original": {

+10

lib/atex/application.ex

···

       1
       1
       +
       defmodule Atex.Application do

     

       2
       2
       +
         @moduledoc false

     

       3
       3
       +
       

     

       4
       4
       +
         use Application

     

       5
       5
       +
       

     

       6
       6
       +
         def start(_type, _args) do

     

       7
       7
       +
           children = [Atex.IdentityResolver.Cache]

     

       8
       8
       +
           Supervisor.start_link(children, strategy: :one_for_one)

     

       9
       9
       +
         end

     

       10
       10
       +
       end

+159

lib/atex/aturi.ex

···

       1
       1
       +
       defmodule Atex.AtURI do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Struct and helper functions for manipulating `at://` URIs, which identify

     

       4
       4
       +
         specific records within the AT Protocol.

     

       5
       5
       +
       

     

       6
       6
       +
         ATProto spec: https://atproto.com/specs/at-uri-scheme

     

       7
       7
       +
       

     

       8
       8
       +
         This module only supports the restricted URI syntax used for the Lexicon

     

       9
       9
       +
         `at-uri` type, with no support for query strings or fragments. If/when the

     

       10
       10
       +
         full syntax gets widespread use, this module will expand to accomodate them.

     

       11
       11
       +
       

     

       12
       12
       +
         Both URIs using DIDs and handles ("example.com") are supported.

     

       13
       13
       +
         """

     

       14
       14
       +
       

     

       15
       15
       +
         use TypedStruct

     

       16
       16
       +
       

     

       17
       17
       +
         @did ~S"did:(?:plc|web):[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]"

     

       18
       18
       +
         @handle ~S"(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?"

     

       19
       19
       +
         @nsid ~S"[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)"

     

       20
       20
       +
       

     

       21
       21
       +
         @authority "(?<authority>(?:#{@did})|(?:#{@handle}))"

     

       22
       22
       +
         @collection "(?<collection>#{@nsid})"

     

       23
       23
       +
         @rkey "(?<rkey>[a-zA-Z0-9.-_:~]{1,512})"

     

       24
       24
       +
       

     

       25
       25
       +
         @re ~r"^at://#{@authority}(?:/#{@collection}(?:/#{@rkey})?)?$"

     

       26
       26
       +
       

     

       27
       27
       +
         typedstruct do

     

       28
       28
       +
           field :authority, String.t(), enforce: true

     

       29
       29
       +
           field :collection, String.t() | nil

     

       30
       30
       +
           field :rkey, String.t() | nil

     

       31
       31
       +
         end

     

       32
       32
       +
       

     

       33
       33
       +
         @doc """

     

       34
       34
       +
         Create a new AtURI struct from a string by matching it against the regex.

     

       35
       35
       +
       

     

       36
       36
       +
         Returns `{:ok, aturi}` if a valid `at://` URI is given, otherwise it will return `:error`.

     

       37
       37
       +
       

     

       38
       38
       +
         ## Examples

     

       39
       39
       +
       

     

       40
       40
       +
             iex> Atex.AtURI.new("at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26")

     

       41
       41
       +
             {:ok, %Atex.AtURI{

     

       42
       42
       +
               rkey: "3jwdwj2ctlk26",

     

       43
       43
       +
               collection: "app.bsky.feed.post",

     

       44
       44
       +
               authority: "did:plc:44ybard66vv44zksje25o7dz"

     

       45
       45
       +
             }}

     

       46
       46
       +
       

     

       47
       47
       +
             iex> Atex.AtURI.new("at:invalid/malformed")

     

       48
       48
       +
             :error

     

       49
       49
       +
       

     

       50
       50
       +
         Partial URIs pointing to a collection without a record key, or even just a given authority, are also supported:

     

       51
       51
       +
       

     

       52
       52
       +
             iex> Atex.AtURI.new("at://ovyerus.com/sh.comet.v0.feed.track")

     

       53
       53
       +
             {:ok, %Atex.AtURI{

     

       54
       54
       +
               rkey: nil,

     

       55
       55
       +
               collection: "sh.comet.v0.feed.track",

     

       56
       56
       +
               authority: "ovyerus.com"

     

       57
       57
       +
             }}

     

       58
       58
       +
       

     

       59
       59
       +
             iex> Atex.AtURI.new("at://did:web:comet.sh")

     

       60
       60
       +
             {:ok, %Atex.AtURI{

     

       61
       61
       +
               rkey: nil,

     

       62
       62
       +
               collection: nil,

     

       63
       63
       +
               authority: "did:web:comet.sh"

     

       64
       64
       +
             }}

     

       65
       65
       +
         """

     

       66
       66
       +
         @spec new(String.t()) :: {:ok, t()} | :error

     

       67
       67
       +
         def new(string) when is_binary(string) do

     

       68
       68
       +
           # TODO: test different ways to get a good error from regex on which part failed match?

     

       69
       69
       +
           case Regex.named_captures(@re, string) do

     

       70
       70
       +
             %{} = captures -> {:ok, from_named_captures(captures)}

     

       71
       71
       +
             nil -> :error

     

       72
       72
       +
           end

     

       73
       73
       +
         end

     

       74
       74
       +
       

     

       75
       75
       +
         @doc """

     

       76
       76
       +
         The same as `new/1` but raises an `ArgumentError` if an invalid string is given.

     

       77
       77
       +
       

     

       78
       78
       +
         ## Examples

     

       79
       79
       +
       

     

       80
       80
       +
             iex> Atex.AtURI.new!("at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26")

     

       81
       81
       +
             %Atex.AtURI{

     

       82
       82
       +
               rkey: "3jwdwj2ctlk26",

     

       83
       83
       +
               collection: "app.bsky.feed.post",

     

       84
       84
       +
               authority: "did:plc:44ybard66vv44zksje25o7dz"

     

       85
       85
       +
             }

     

       86
       86
       +
       

     

       87
       87
       +
             iex> Atex.AtURI.new!("at:invalid/malformed")

     

       88
       88
       +
             ** (ArgumentError) Malformed at:// URI

     

       89
       89
       +
         """

     

       90
       90
       +
         @spec new!(String.t()) :: t()

     

       91
       91
       +
         def new!(string) when is_binary(string) do

     

       92
       92
       +
           case new(string) do

     

       93
       93
       +
             {:ok, uri} -> uri

     

       94
       94
       +
             :error -> raise ArgumentError, message: "Malformed at:// URI"

     

       95
       95
       +
           end

     

       96
       96
       +
         end

     

       97
       97
       +
       

     

       98
       98
       +
         @doc """

     

       99
       99
       +
         Check if a string is a valid `at://` URI.

     

       100
       100
       +
       

     

       101
       101
       +
         ## Examples

     

       102
       102
       +
       

     

       103
       103
       +
             iex> Atex.AtURI.match?("at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26")

     

       104
       104
       +
             true

     

       105
       105
       +
       

     

       106
       106
       +
             iex> Atex.AtURI.match?("at://did:web:comet.sh")

     

       107
       107
       +
             true

     

       108
       108
       +
       

     

       109
       109
       +
             iex> Atex.AtURI.match?("at://ovyerus.com/sh.comet.v0.feed.track")

     

       110
       110
       +
             true

     

       111
       111
       +
       

     

       112
       112
       +
             iex> Atex.AtURI.match?("gobbledy gook")

     

       113
       113
       +
             false

     

       114
       114
       +
         """

     

       115
       115
       +
         @spec match?(String.t()) :: boolean()

     

       116
       116
       +
         def match?(string), do: Regex.match?(@re, string)

     

       117
       117
       +
       

     

       118
       118
       +
         @doc """

     

       119
       119
       +
         Format an `Atex.AtURI` to the canonical string representation.

     

       120
       120
       +
       

     

       121
       121
       +
         Also available via the `String.Chars` protocol.

     

       122
       122
       +
       

     

       123
       123
       +
         ## Examples

     

       124
       124
       +
       

     

       125
       125
       +
             iex> aturi = %Atex.AtURI{

     

       126
       126
       +
             ...>   rkey: "3jwdwj2ctlk26",

     

       127
       127
       +
             ...>   collection: "app.bsky.feed.post",

     

       128
       128
       +
             ...>   authority: "did:plc:44ybard66vv44zksje25o7dz"

     

       129
       129
       +
             ...> }

     

       130
       130
       +
             iex> Atex.AtURI.to_string(aturi)

     

       131
       131
       +
             "at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26"

     

       132
       132
       +
       

     

       133
       133
       +
             iex> aturi = %Atex.AtURI{authority: "did:web:comet.sh"}

     

       134
       134
       +
             iex> to_string(aturi)

     

       135
       135
       +
             "at://did:web:comet.sh"

     

       136
       136
       +
         """

     

       137
       137
       +
         @spec to_string(t()) :: String.t()

     

       138
       138
       +
         def to_string(%__MODULE__{} = uri) do

     

       139
       139
       +
           "at://#{uri.authority}/#{uri.collection}/#{uri.rkey}"

     

       140
       140
       +
           |> String.trim_trailing("/")

     

       141
       141
       +
         end

     

       142
       142
       +
       

     

       143
       143
       +
         defp from_named_captures(%{"authority" => authority, "collection" => "", "rkey" => ""}),

     

       144
       144
       +
           do: %__MODULE__{authority: authority}

     

       145
       145
       +
       

     

       146
       146
       +
         defp from_named_captures(%{"authority" => authority, "collection" => collection, "rkey" => ""}),

     

       147
       147
       +
           do: %__MODULE__{authority: authority, collection: collection}

     

       148
       148
       +
       

     

       149
       149
       +
         defp from_named_captures(%{

     

       150
       150
       +
                "authority" => authority,

     

       151
       151
       +
                "collection" => collection,

     

       152
       152
       +
                "rkey" => rkey

     

       153
       153
       +
              }),

     

       154
       154
       +
              do: %__MODULE__{authority: authority, collection: collection, rkey: rkey}

     

       155
       155
       +
       end

     

       156
       156
       +
       

     

       157
       157
       +
       defimpl String.Chars, for: Atex.AtURI do

     

       158
       158
       +
         def to_string(uri), do: Atex.AtURI.to_string(uri)

     

       159
       159
       +
       end

+39

lib/atex/base32_sortable.ex

···

       1
       1
       +
       defmodule Atex.Base32Sortable do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Codec for the base32-sortable encoding.

     

       4
       4
       +
         """

     

       5
       5
       +
       

     

       6
       6
       +
         @alphabet ~c(234567abcdefghijklmnopqrstuvwxyz)

     

       7
       7
       +
         @alphabet_len length(@alphabet)

     

       8
       8
       +
       

     

       9
       9
       +
         @doc """

     

       10
       10
       +
         Encode an integer as a base32-sortable string.

     

       11
       11
       +
         """

     

       12
       12
       +
         @spec encode(integer()) :: String.t()

     

       13
       13
       +
         def encode(int) when is_integer(int), do: do_encode(int, "")

     

       14
       14
       +
       

     

       15
       15
       +
         @spec do_encode(integer(), String.t()) :: String.t()

     

       16
       16
       +
         defp do_encode(0, acc), do: acc

     

       17
       17
       +
       

     

       18
       18
       +
         defp do_encode(int, acc) do

     

       19
       19
       +
           char_index = rem(int, @alphabet_len)

     

       20
       20
       +
           new_int = div(int, @alphabet_len)

     

       21
       21
       +
       

     

       22
       22
       +
           # Chars are prepended to the accumulator because rem/div is pulling them off the tail of the integer.

     

       23
       23
       +
           do_encode(new_int, <<Enum.at(@alphabet, char_index)>> <> acc)

     

       24
       24
       +
         end

     

       25
       25
       +
       

     

       26
       26
       +
         @doc """

     

       27
       27
       +
         Decode a base32-sortable string to an integer.

     

       28
       28
       +
         """

     

       29
       29
       +
         @spec decode(String.t()) :: integer()

     

       30
       30
       +
         def decode(str) when is_binary(str), do: do_decode(str, 0)

     

       31
       31
       +
       

     

       32
       32
       +
         @spec do_decode(String.t(), integer()) :: integer()

     

       33
       33
       +
         defp do_decode(<<>>, acc), do: acc

     

       34
       34
       +
       

     

       35
       35
       +
         defp do_decode(<<char::utf8, rest::binary>>, acc) do

     

       36
       36
       +
           i = Enum.find_index(@alphabet, fn x -> x == char end)

     

       37
       37
       +
           do_decode(rest, acc * @alphabet_len + i)

     

       38
       38
       +
         end

     

       39
       39
       +
       end

+86

lib/atex/config/oauth.ex

···

       1
       1
       +
       defmodule Atex.Config.OAuth do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Configuration management for `Atex.OAuth`.

     

       4
       4
       +
       

     

       5
       5
       +
         Contains all the logic for fetching configuration needed for the OAuth

     

       6
       6
       +
         module, as well as deriving useful values from them.

     

       7
       7
       +
       

     

       8
       8
       +
         ## Configuration

     

       9
       9
       +
       

     

       10
       10
       +
         The following structure is expected in your application config:

     

       11
       11
       +
       

     

       12
       12
       +
             config :atex, Atex.OAuth,

     

       13
       13
       +
               base_url: "https://example.com/oauth",  # Your application's base URL, including the path `Atex.OAuth` is mounted on.

     

       14
       14
       +
               private_key: "base64-encoded-private-key",  # ES256 private key

     

       15
       15
       +
               key_id: "your-key-id",  # Key identifier for JWTs

     

       16
       16
       +
               scopes: ["transition:generic", "transition:email"],  # Optional additional scopes

     

       17
       17
       +
               extra_redirect_uris: ["https://alternative.com/callback"],  # Optional additional redirect URIs

     

       18
       18
       +
               is_localhost: false  # Set to true for local development

     

       19
       19
       +
         """

     

       20
       20
       +
       

     

       21
       21
       +
         @doc """

     

       22
       22
       +
         Returns the configured public base URL for OAuth routes.

     

       23
       23
       +
         """

     

       24
       24
       +
         @spec base_url() :: String.t()

     

       25
       25
       +
         def base_url, do: Application.fetch_env!(:atex, Atex.OAuth)[:base_url]

     

       26
       26
       +
       

     

       27
       27
       +
         @doc """

     

       28
       28
       +
         Returns the configured private key as a `JOSE.JWK`.

     

       29
       29
       +
         """

     

       30
       30
       +
         @spec get_key() :: JOSE.JWK.t()

     

       31
       31
       +
         def get_key() do

     

       32
       32
       +
           private_key =

     

       33
       33
       +
             Application.fetch_env!(:atex, Atex.OAuth)[:private_key]

     

       34
       34
       +
             |> Base.decode64!()

     

       35
       35
       +
             |> JOSE.JWK.from_der()

     

       36
       36
       +
       

     

       37
       37
       +
           key_id = Application.fetch_env!(:atex, Atex.OAuth)[:key_id]

     

       38
       38
       +
       

     

       39
       39
       +
           %{private_key | fields: %{"kid" => key_id}}

     

       40
       40
       +
         end

     

       41
       41
       +
       

     

       42
       42
       +
         @doc """

     

       43
       43
       +
         Returns the client ID based on configuration.

     

       44
       44
       +
       

     

       45
       45
       +
         If `is_localhost` is set, it'll be a string handling the "http://localhost"

     

       46
       46
       +
         special case, with the redirect URI and scopes configured, otherwise it is a

     

       47
       47
       +
         string pointing to the location of the `client-metadata.json` route.

     

       48
       48
       +
         """

     

       49
       49
       +
         @spec client_id() :: String.t()

     

       50
       50
       +
         def client_id() do

     

       51
       51
       +
           is_localhost = Keyword.get(Application.get_env(:atex, Atex.OAuth, []), :is_localhost, false)

     

       52
       52
       +
       

     

       53
       53
       +
           if is_localhost do

     

       54
       54
       +
             query =

     

       55
       55
       +
               %{redirect_uri: redirect_uri(), scope: scopes()}

     

       56
       56
       +
               |> URI.encode_query()

     

       57
       57
       +
       

     

       58
       58
       +
             "http://localhost?#{query}"

     

       59
       59
       +
           else

     

       60
       60
       +
             "#{base_url()}/client-metadata.json"

     

       61
       61
       +
           end

     

       62
       62
       +
         end

     

       63
       63
       +
       

     

       64
       64
       +
         @doc """

     

       65
       65
       +
         Returns the configured redirect URI.

     

       66
       66
       +
         """

     

       67
       67
       +
         @spec redirect_uri() :: String.t()

     

       68
       68
       +
         def redirect_uri(), do: "#{base_url()}/callback"

     

       69
       69
       +
       

     

       70
       70
       +
         @doc """

     

       71
       71
       +
         Returns the configured scopes joined as a space-separated string.

     

       72
       72
       +
         """

     

       73
       73
       +
         @spec scopes() :: String.t()

     

       74
       74
       +
         def scopes() do

     

       75
       75
       +
           config_scopes = Keyword.get(Application.get_env(:atex, Atex.OAuth, []), :scopes, [])

     

       76
       76
       +
           Enum.join(["atproto" | config_scopes], " ")

     

       77
       77
       +
         end

     

       78
       78
       +
       

     

       79
       79
       +
         @doc """

     

       80
       80
       +
         Returns the configured extra redirect URIs.

     

       81
       81
       +
         """

     

       82
       82
       +
         @spec extra_redirect_uris() :: [String.t()]

     

       83
       83
       +
         def extra_redirect_uris() do

     

       84
       84
       +
           Keyword.get(Application.get_env(:atex, Atex.OAuth, []), :extra_redirect_uris, [])

     

       85
       85
       +
         end

     

       86
       86
       +
       end

+16

lib/atex/did.ex

···

       1
       1
       +
       defmodule Atex.DID do

     

       2
       2
       +
         @re ~r/^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/

     

       3
       3
       +
         @blessed_re ~r/^did:(?:plc|web):[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/

     

       4
       4
       +
       

     

       5
       5
       +
         @spec re() :: Regex.t()

     

       6
       6
       +
         def re, do: @re

     

       7
       7
       +
       

     

       8
       8
       +
         @spec match?(String.t()) :: boolean()

     

       9
       9
       +
         def match?(value), do: Regex.match?(@re, value)

     

       10
       10
       +
       

     

       11
       11
       +
         @spec blessed_re() :: Regex.t()

     

       12
       12
       +
         def blessed_re, do: @blessed_re

     

       13
       13
       +
       

     

       14
       14
       +
         @spec match_blessed?(String.t()) :: boolean()

     

       15
       15
       +
         def match_blessed?(value), do: Regex.match?(@blessed_re, value)

     

       16
       16
       +
       end

lib/atex/handle.ex

···

       1
       1
       +
       defmodule Atex.Handle do

     

       2
       2
       +
         @re ~r/^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/

     

       3
       3
       +
       

     

       4
       4
       +
         @spec re() :: Regex.t()

     

       5
       5
       +
         def re, do: @re

     

       6
       6
       +
       

     

       7
       7
       +
         @spec match?(String.t()) :: boolean()

     

       8
       8
       +
         def match?(value), do: Regex.match?(@re, value)

     

       9
       9
       +
       end

+57

lib/atex/identity_resolver/cache/ets.ex

···

       1
       1
       +
       defmodule Atex.IdentityResolver.Cache.ETS do

     

       2
       2
       +
         alias Atex.IdentityResolver.Identity

     

       3
       3
       +
         @behaviour Atex.IdentityResolver.Cache

     

       4
       4
       +
         use Supervisor

     

       5
       5
       +
       

     

       6
       6
       +
         @table :atex_identities

     

       7
       7
       +
       

     

       8
       8
       +
         def start_link(opts) do

     

       9
       9
       +
           Supervisor.start_link(__MODULE__, opts)

     

       10
       10
       +
         end

     

       11
       11
       +
       

     

       12
       12
       +
         @impl Supervisor

     

       13
       13
       +
         def init(_opts) do

     

       14
       14
       +
           :ets.new(@table, [:set, :public, :named_table])

     

       15
       15
       +
           Supervisor.init([], strategy: :one_for_one)

     

       16
       16
       +
         end

     

       17
       17
       +
       

     

       18
       18
       +
         @impl Atex.IdentityResolver.Cache

     

       19
       19
       +
         @spec insert(Identity.t()) :: Identity.t()

     

       20
       20
       +
         def insert(identity) do

     

       21
       21
       +
           # TODO: benchmark lookups vs match performance, is it better to use a "composite" key or two inserts?

     

       22
       22
       +
           :ets.insert(@table, {{identity.did, identity.handle}, identity})

     

       23
       23
       +
           identity

     

       24
       24
       +
         end

     

       25
       25
       +
       

     

       26
       26
       +
         @impl Atex.IdentityResolver.Cache

     

       27
       27
       +
         @spec get(String.t()) :: {:ok, Identity.t()} | {:error, atom()}

     

       28
       28
       +
         def get(identifier) do

     

       29
       29
       +
           lookup(identifier)

     

       30
       30
       +
         end

     

       31
       31
       +
       

     

       32
       32
       +
         @impl Atex.IdentityResolver.Cache

     

       33
       33
       +
         @spec delete(String.t()) :: :noop | Identity.t()

     

       34
       34
       +
         def delete(identifier) do

     

       35
       35
       +
           case lookup(identifier) do

     

       36
       36
       +
             {:ok, identity} ->

     

       37
       37
       +
               :ets.delete(@table, {identity.did, identity.handle})

     

       38
       38
       +
               identity

     

       39
       39
       +
       

     

       40
       40
       +
             _ ->

     

       41
       41
       +
               :noop

     

       42
       42
       +
           end

     

       43
       43
       +
         end

     

       44
       44
       +
       

     

       45
       45
       +
         defp lookup(identifier) do

     

       46
       46
       +
           case :ets.match(@table, {{identifier, :_}, :"$1"}) do

     

       47
       47
       +
             [] ->

     

       48
       48
       +
               case :ets.match(@table, {{:_, identifier}, :"$1"}) do

     

       49
       49
       +
                 [] -> {:error, :not_found}

     

       50
       50
       +
                 [[identity]] -> {:ok, identity}

     

       51
       51
       +
               end

     

       52
       52
       +
       

     

       53
       53
       +
             [[identity]] ->

     

       54
       54
       +
               {:ok, identity}

     

       55
       55
       +
           end

     

       56
       56
       +
         end

     

       57
       57
       +
       end

+42

lib/atex/identity_resolver/cache.ex

···

       1
       1
       +
       defmodule Atex.IdentityResolver.Cache do

     

       2
       2
       +
         # TODO: need the following:

     

       3
       3
       +
         # did -> handle mapping

     

       4
       4
       +
         # handle -> did mapping

     

       5
       5
       +
         # did -> document mapping?

     

       6
       6
       +
         # User should be able to call a single function to fetch all info for either did and handle, including the link between them.

     

       7
       7
       +
         # Need some sort of TTL so that we can refresh as necessary

     

       8
       8
       +
         alias Atex.IdentityResolver.Identity

     

       9
       9
       +
       

     

       10
       10
       +
         @cache Application.compile_env(:atex, :identity_cache, Atex.IdentityResolver.Cache.ETS)

     

       11
       11
       +
       

     

       12
       12
       +
         @doc """

     

       13
       13
       +
         Add a new identity to the cache. Can also be used to update an identity that may already exist.

     

       14
       14
       +
       

     

       15
       15
       +
         Returns the input `t:Atex.IdentityResolver.Identity.t/0`.

     

       16
       16
       +
         """

     

       17
       17
       +
         @callback insert(identity :: Identity.t()) :: Identity.t()

     

       18
       18
       +
       

     

       19
       19
       +
         @doc """

     

       20
       20
       +
         Retrieve an identity from the cache by DID *or* handle.

     

       21
       21
       +
         """

     

       22
       22
       +
         @callback get(String.t()) :: {:ok, Identity.t()} | {:error, atom()}

     

       23
       23
       +
       

     

       24
       24
       +
         @doc """

     

       25
       25
       +
         Delete an identity in the cache.

     

       26
       26
       +
         """

     

       27
       27
       +
         @callback delete(String.t()) :: :noop | Identity.t()

     

       28
       28
       +
       

     

       29
       29
       +
         @doc """

     

       30
       30
       +
         Get the child specification for starting the cache in a supervision tree.

     

       31
       31
       +
         """

     

       32
       32
       +
         @callback child_spec(any()) :: Supervisor.child_spec()

     

       33
       33
       +
       

     

       34
       34
       +
         defdelegate get(identifier), to: @cache

     

       35
       35
       +
       

     

       36
       36
       +
         @doc false

     

       37
       37
       +
         defdelegate insert(payload), to: @cache

     

       38
       38
       +
         @doc false

     

       39
       39
       +
         defdelegate delete(snowflake), to: @cache

     

       40
       40
       +
         @doc false

     

       41
       41
       +
         defdelegate child_spec(opts), to: @cache

     

       42
       42
       +
       end

+51

lib/atex/identity_resolver/did.ex

···

       1
       1
       +
       defmodule Atex.IdentityResolver.DID do

     

       2
       2
       +
         alias Atex.IdentityResolver.DIDDocument

     

       3
       3
       +
       

     

       4
       4
       +
         @type resolution_result() ::

     

       5
       5
       +
                 {:ok, DIDDocument.t()}

     

       6
       6
       +
                 | {:error, :invalid_did_type | :invalid_did | :not_found | map() | atom() | any()}

     

       7
       7
       +
       

     

       8
       8
       +
         @spec resolve(String.t()) :: resolution_result()

     

       9
       9
       +
         def resolve("did:plc:" <> _ = did), do: resolve_plc(did)

     

       10
       10
       +
         def resolve("did:web:" <> _ = did), do: resolve_web(did)

     

       11
       11
       +
         def resolve("did:" <> _), do: {:error, :invalid_did_type}

     

       12
       12
       +
         def resolve(_did), do: {:error, :invalid_did}

     

       13
       13
       +
       

     

       14
       14
       +
         @spec resolve_plc(String.t()) :: resolution_result()

     

       15
       15
       +
         defp resolve_plc("did:plc:" <> _id = did) do

     

       16
       16
       +
           with {:ok, resp} when resp.status in 200..299 <-

     

       17
       17
       +
                  Req.get("https://plc.directory/#{did}"),

     

       18
       18
       +
                {:ok, body} <- decode_body(resp.body),

     

       19
       19
       +
                {:ok, document} <- DIDDocument.from_json(body),

     

       20
       20
       +
                :ok <- DIDDocument.validate_for_atproto(document, did) do

     

       21
       21
       +
             {:ok, document}

     

       22
       22
       +
           else

     

       23
       23
       +
             {:ok, %{status: status}} when status in [404, 410] -> {:error, :not_found}

     

       24
       24
       +
             {:ok, %{} = resp} -> {:error, resp}

     

       25
       25
       +
             e -> e

     

       26
       26
       +
           end

     

       27
       27
       +
         end

     

       28
       28
       +
       

     

       29
       29
       +
         @spec resolve_web(String.t()) :: resolution_result()

     

       30
       30
       +
         defp resolve_web("did:web:" <> domain = did) do

     

       31
       31
       +
           with {:ok, resp} when resp.status in 200..299 <-

     

       32
       32
       +
                  Req.get("https://#{domain}/.well-known/did.json"),

     

       33
       33
       +
                {:ok, body} <- decode_body(resp.body),

     

       34
       34
       +
                {:ok, document} <- DIDDocument.from_json(body),

     

       35
       35
       +
                :ok <- DIDDocument.validate_for_atproto(document, did) do

     

       36
       36
       +
             {:ok, document}

     

       37
       37
       +
           else

     

       38
       38
       +
             {:ok, %{status: 404}} -> {:error, :not_found}

     

       39
       39
       +
             {:ok, %{} = resp} -> {:error, resp}

     

       40
       40
       +
             e -> e

     

       41
       41
       +
           end

     

       42
       42
       +
         end

     

       43
       43
       +
       

     

       44
       44
       +
         @spec decode_body(any()) ::

     

       45
       45
       +
                 {:ok, any()}

     

       46
       46
       +
                 | {:error, :invalid_body | JSON.decode_error_reason()}

     

       47
       47
       +
       

     

       48
       48
       +
         defp decode_body(body) when is_binary(body), do: JSON.decode(body)

     

       49
       49
       +
         defp decode_body(body) when is_map(body), do: {:ok, body}

     

       50
       50
       +
         defp decode_body(_body), do: {:error, :invalid_body}

     

       51
       51
       +
       end

+155

lib/atex/identity_resolver/did_document.ex

···

       1
       1
       +
       defmodule Atex.IdentityResolver.DIDDocument do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Struct and schema for describing and validating a [DID document](https://github.com/w3c/did-wg/blob/main/did-explainer.md#did-documents).

     

       4
       4
       +
         """

     

       5
       5
       +
         import Peri

     

       6
       6
       +
         use TypedStruct

     

       7
       7
       +
       

     

       8
       8
       +
         defschema :schema, %{

     

       9
       9
       +
           "@context": {:required, {:list, Atex.Peri.uri()}},

     

       10
       10
       +
           id: {:required, :string},

     

       11
       11
       +
           controller: {:either, {Atex.Peri.did(), {:list, Atex.Peri.did()}}},

     

       12
       12
       +
           also_known_as: {:list, Atex.Peri.uri()},

     

       13
       13
       +
           verification_method: {:list, get_schema(:verification_method)},

     

       14
       14
       +
           authentication: {:list, {:either, {Atex.Peri.uri(), get_schema(:verification_method)}}},

     

       15
       15
       +
           service: {:list, get_schema(:service)}

     

       16
       16
       +
         }

     

       17
       17
       +
       

     

       18
       18
       +
         defschema :verification_method, %{

     

       19
       19
       +
           id: {:required, Atex.Peri.uri()},

     

       20
       20
       +
           type: {:required, :string},

     

       21
       21
       +
           controller: {:required, Atex.Peri.did()},

     

       22
       22
       +
           public_key_multibase: :string,

     

       23
       23
       +
           public_key_jwk: :map

     

       24
       24
       +
         }

     

       25
       25
       +
       

     

       26
       26
       +
         defschema :service, %{

     

       27
       27
       +
           id: {:required, Atex.Peri.uri()},

     

       28
       28
       +
           type: {:required, {:either, {:string, {:list, :string}}}},

     

       29
       29
       +
           service_endpoint:

     

       30
       30
       +
             {:required,

     

       31
       31
       +
              {:oneof,

     

       32
       32
       +
               [

     

       33
       33
       +
                 Atex.Peri.uri(),

     

       34
       34
       +
                 {:map, Atex.Peri.uri()},

     

       35
       35
       +
                 {:list, {:either, {Atex.Peri.uri(), {:map, Atex.Peri.uri()}}}}

     

       36
       36
       +
               ]}}

     

       37
       37
       +
         }

     

       38
       38
       +
       

     

       39
       39
       +
         @type verification_method() :: %{

     

       40
       40
       +
                 required(:id) => String.t(),

     

       41
       41
       +
                 required(:type) => String.t(),

     

       42
       42
       +
                 required(:controller) => String.t(),

     

       43
       43
       +
                 optional(:public_key_multibase) => String.t(),

     

       44
       44
       +
                 optional(:public_key_jwk) => map()

     

       45
       45
       +
               }

     

       46
       46
       +
       

     

       47
       47
       +
         @type service() :: %{

     

       48
       48
       +
                 required(:id) => String.t(),

     

       49
       49
       +
                 required(:type) => String.t() | list(String.t()),

     

       50
       50
       +
                 required(:service_endpoint) =>

     

       51
       51
       +
                   String.t()

     

       52
       52
       +
                   | %{String.t() => String.t()}

     

       53
       53
       +
                   | list(String.t() | %{String.t() => String.t()})

     

       54
       54
       +
               }

     

       55
       55
       +
       

     

       56
       56
       +
         typedstruct do

     

       57
       57
       +
           field :"@context", list(String.t()), enforce: true

     

       58
       58
       +
           field :id, String.t(), enforce: true

     

       59
       59
       +
           field :controller, String.t() | list(String.t())

     

       60
       60
       +
           field :also_known_as, list(String.t())

     

       61
       61
       +
           field :verification_method, list(verification_method())

     

       62
       62
       +
           field :authentication, list(String.t() | verification_method())

     

       63
       63
       +
           field :service, list(service())

     

       64
       64
       +
         end

     

       65
       65
       +
       

     

       66
       66
       +
         def new(params), do: struct(__MODULE__, params)

     

       67
       67
       +
       

     

       68
       68
       +
         @spec from_json(map()) :: {:ok, t()} | {:error, Peri.Error.t()}

     

       69
       69
       +
         def from_json(%{} = map) do

     

       70
       70
       +
           map

     

       71
       71
       +
           |> Recase.Enumerable.convert_keys(&Recase.to_snake/1)

     

       72
       72
       +
           |> schema()

     

       73
       73
       +
           |> case do

     

       74
       74
       +
             # {:ok, params} -> {:ok, struct(__MODULE__, params)}

     

       75
       75
       +
             {:ok, params} -> {:ok, new(params)}

     

       76
       76
       +
             e -> e

     

       77
       77
       +
           end

     

       78
       78
       +
         end

     

       79
       79
       +
       

     

       80
       80
       +
         @spec validate_for_atproto(t(), String.t()) :: any()

     

       81
       81
       +
         def validate_for_atproto(%__MODULE__{} = doc, did) do

     

       82
       82
       +
           # TODO: make sure this is  ok

     

       83
       83
       +
           id_matches = doc.id == did

     

       84
       84
       +
       

     

       85
       85
       +
           valid_signing_key =

     

       86
       86
       +
             Enum.any?(doc.verification_method, fn method ->

     

       87
       87
       +
               String.ends_with?(method.id, "#atproto") and method.controller == did

     

       88
       88
       +
             end)

     

       89
       89
       +
       

     

       90
       90
       +
           valid_pds_service =

     

       91
       91
       +
             Enum.any?(doc.service, fn service ->

     

       92
       92
       +
               String.ends_with?(service.id, "#atproto_pds") and

     

       93
       93
       +
                 service.type == "AtprotoPersonalDataServer" and

     

       94
       94
       +
                 valid_pds_endpoint?(service.service_endpoint)

     

       95
       95
       +
             end)

     

       96
       96
       +
       

     

       97
       97
       +
           case {id_matches, valid_signing_key, valid_pds_service} do

     

       98
       98
       +
             {true, true, true} -> :ok

     

       99
       99
       +
             {false, _, _} -> {:error, :id_mismatch}

     

       100
       100
       +
             {_, false, _} -> {:error, :no_signing_key}

     

       101
       101
       +
             {_, _, false} -> {:error, :invalid_pds}

     

       102
       102
       +
           end

     

       103
       103
       +
         end

     

       104
       104
       +
       

     

       105
       105
       +
         @doc """

     

       106
       106
       +
         Get the associated ATProto handle in the DID document.

     

       107
       107
       +
       

     

       108
       108
       +
         ATProto dictates that only the first valid handle is to be used, so this

     

       109
       109
       +
         follows that rule.

     

       110
       110
       +
       

     

       111
       111
       +
         > #### Note {: .info}

     

       112
       112
       +
         >

     

       113
       113
       +
         > While DID documents are fairly authoritative, you need to make sure to

     

       114
       114
       +
         > validate the handle bidirectionally. See

     

       115
       115
       +
         > `Atex.IdentityResolver.Handle.resolve/2`.

     

       116
       116
       +
         """

     

       117
       117
       +
         @spec get_atproto_handle(t()) :: String.t() | nil

     

       118
       118
       +
         def get_atproto_handle(%__MODULE__{also_known_as: nil}), do: nil

     

       119
       119
       +
       

     

       120
       120
       +
         def get_atproto_handle(%__MODULE__{} = doc) do

     

       121
       121
       +
           Enum.find_value(doc.also_known_as, fn

     

       122
       122
       +
             # TODO: make sure no path or other URI parts

     

       123
       123
       +
             "at://" <> handle -> handle

     

       124
       124
       +
             _ -> nil

     

       125
       125
       +
           end)

     

       126
       126
       +
         end

     

       127
       127
       +
       

     

       128
       128
       +
         @spec get_pds_endpoint(t()) :: String.t() | nil

     

       129
       129
       +
         def get_pds_endpoint(%__MODULE__{} = doc) do

     

       130
       130
       +
           doc.service

     

       131
       131
       +
           |> Enum.find(fn

     

       132
       132
       +
             %{id: "#atproto_pds", type: "AtprotoPersonalDataServer"} -> true

     

       133
       133
       +
             _ -> false

     

       134
       134
       +
           end)

     

       135
       135
       +
           |> case do

     

       136
       136
       +
             nil -> nil

     

       137
       137
       +
             pds -> pds.service_endpoint

     

       138
       138
       +
           end

     

       139
       139
       +
         end

     

       140
       140
       +
       

     

       141
       141
       +
         defp valid_pds_endpoint?(endpoint) do

     

       142
       142
       +
           case URI.new(endpoint) do

     

       143
       143
       +
             {:ok, uri} ->

     

       144
       144
       +
               is_plain_uri =

     

       145
       145
       +
                 uri

     

       146
       146
       +
                 |> Map.from_struct()

     

       147
       147
       +
                 |> Enum.all?(fn

     

       148
       148
       +
                   {key, value} when key in [:userinfo, :path, :query, :fragment] -> is_nil(value)

     

       149
       149
       +
                   _ -> true

     

       150
       150
       +
                 end)

     

       151
       151
       +
       

     

       152
       152
       +
               uri.scheme in ["https", "http"] and is_plain_uri

     

       153
       153
       +
           end

     

       154
       154
       +
         end

     

       155
       155
       +
       end

+74

lib/atex/identity_resolver/handle.ex

···

       1
       1
       +
       defmodule Atex.IdentityResolver.Handle do

     

       2
       2
       +
         @type strategy() :: :dns_first | :http_first | :race | :both

     

       3
       3
       +
       

     

       4
       4
       +
         @spec resolve(String.t(), strategy()) ::

     

       5
       5
       +
                 {:ok, String.t()} | :error | {:error, :ambiguous_handle}

     

       6
       6
       +
         def resolve(handle, strategy)

     

       7
       7
       +
       

     

       8
       8
       +
         def resolve(handle, :dns_first) do

     

       9
       9
       +
           case resolve_via_dns(handle) do

     

       10
       10
       +
             :error -> resolve_via_http(handle)

     

       11
       11
       +
             ok -> ok

     

       12
       12
       +
           end

     

       13
       13
       +
         end

     

       14
       14
       +
       

     

       15
       15
       +
         def resolve(handle, :http_first) do

     

       16
       16
       +
           case resolve_via_http(handle) do

     

       17
       17
       +
             :error -> resolve_via_dns(handle)

     

       18
       18
       +
             ok -> ok

     

       19
       19
       +
           end

     

       20
       20
       +
         end

     

       21
       21
       +
       

     

       22
       22
       +
         def resolve(handle, :race) do

     

       23
       23
       +
           [&resolve_via_dns/1, &resolve_via_http/1]

     

       24
       24
       +
           |> Task.async_stream(& &1.(handle), max_concurrency: 2, ordered: false)

     

       25
       25
       +
           |> Stream.filter(&match?({:ok, {:ok, _}}, &1))

     

       26
       26
       +
           |> Enum.at(0)

     

       27
       27
       +
         end

     

       28
       28
       +
       

     

       29
       29
       +
         def resolve(handle, :both) do

     

       30
       30
       +
           case Task.await_many([

     

       31
       31
       +
                  Task.async(fn -> resolve_via_dns(handle) end),

     

       32
       32
       +
                  Task.async(fn -> resolve_via_http(handle) end)

     

       33
       33
       +
                ]) do

     

       34
       34
       +
             [{:ok, dns_did}, {:ok, http_did}] ->

     

       35
       35
       +
               if dns_did && http_did && dns_did != http_did do

     

       36
       36
       +
                 {:error, :ambiguous_handle}

     

       37
       37
       +
               else

     

       38
       38
       +
                 {:ok, dns_did}

     

       39
       39
       +
               end

     

       40
       40
       +
       

     

       41
       41
       +
             _ ->

     

       42
       42
       +
               :error

     

       43
       43
       +
           end

     

       44
       44
       +
         end

     

       45
       45
       +
       

     

       46
       46
       +
         @spec resolve_via_dns(String.t()) :: {:ok, String.t()} | :error

     

       47
       47
       +
         defp resolve_via_dns(handle) do

     

       48
       48
       +
           with ["did=" <> did] <- query_dns("_atproto.#{handle}", :txt),

     

       49
       49
       +
                "did:" <> _ <- did do

     

       50
       50
       +
             {:ok, did}

     

       51
       51
       +
           else

     

       52
       52
       +
             _ -> :error

     

       53
       53
       +
           end

     

       54
       54
       +
         end

     

       55
       55
       +
       

     

       56
       56
       +
         @spec resolve_via_http(String.t()) :: {:ok, String.t()} | :error

     

       57
       57
       +
         defp resolve_via_http(handle) do

     

       58
       58
       +
           case Req.get("https://#{handle}/.well-known/atproto-did") do

     

       59
       59
       +
             {:ok, %{body: "did:" <> _ = did}} -> {:ok, did}

     

       60
       60
       +
             _ -> :error

     

       61
       61
       +
           end

     

       62
       62
       +
         end

     

       63
       63
       +
       

     

       64
       64
       +
         @spec query_dns(String.t(), :inet_res.dns_rr_type()) :: list(String.t() | list(String.t()))

     

       65
       65
       +
         defp query_dns(domain, type) do

     

       66
       66
       +
           domain

     

       67
       67
       +
           |> String.to_charlist()

     

       68
       68
       +
           |> :inet_res.lookup(:in, type)

     

       69
       69
       +
           |> Enum.map(fn

     

       70
       70
       +
             [result] -> to_string(result)

     

       71
       71
       +
             result -> result

     

       72
       72
       +
           end)

     

       73
       73
       +
         end

     

       74
       74
       +
       end

+25

lib/atex/identity_resolver/identity.ex

···

       1
       1
       +
       defmodule Atex.IdentityResolver.Identity do

     

       2
       2
       +
         use TypedStruct

     

       3
       3
       +
       

     

       4
       4
       +
         @typedoc """

     

       5
       5
       +
         The controlling DID for an identity.

     

       6
       6
       +
         """

     

       7
       7
       +
         @type did() :: String.t()

     

       8
       8
       +
         @typedoc """

     

       9
       9
       +
         The human-readable handle for an identity. Can be missing.

     

       10
       10
       +
         """

     

       11
       11
       +
         @type handle() :: String.t() | nil

     

       12
       12
       +
         @typedoc """

     

       13
       13
       +
         The resolved DID document for an identity.

     

       14
       14
       +
         """

     

       15
       15
       +
         @type document() :: Atex.IdentityResolver.DIDDocument.t()

     

       16
       16
       +
       

     

       17
       17
       +
         typedstruct do

     

       18
       18
       +
           field :did, did(), enforce: true

     

       19
       19
       +
           field :handle, handle()

     

       20
       20
       +
           field :document, document(), enforce: true

     

       21
       21
       +
         end

     

       22
       22
       +
       

     

       23
       23
       +
         @spec new(did(), handle(), document()) :: t()

     

       24
       24
       +
         def new(did, handle, document), do: %__MODULE__{did: did, handle: handle, document: document}

     

       25
       25
       +
       end

+56

lib/atex/identity_resolver.ex

···

       1
       1
       +
       defmodule Atex.IdentityResolver do

     

       2
       2
       +
         alias Atex.IdentityResolver.{Cache, DID, DIDDocument, Handle, Identity}

     

       3
       3
       +
       

     

       4
       4
       +
         @handle_strategy Application.compile_env(:atex, :handle_resolver_strategy, :dns_first)

     

       5
       5
       +
         @type options() :: {:skip_cache, boolean()}

     

       6
       6
       +
       

     

       7
       7
       +
         # TODO: simplify errors

     

       8
       8
       +
       

     

       9
       9
       +
         @spec resolve(String.t(), list(options())) :: {:ok, Identity.t()} | {:error, any()}

     

       10
       10
       +
         def resolve(identifier, opts \\ []) do

     

       11
       11
       +
           opts = Keyword.validate!(opts, skip_cache: false)

     

       12
       12
       +
           skip_cache = Keyword.get(opts, :skip_cache)

     

       13
       13
       +
       

     

       14
       14
       +
           cache_result = if skip_cache, do: {:error, :not_found}, else: Cache.get(identifier)

     

       15
       15
       +
       

     

       16
       16
       +
           # If cache fetch succeeds, then the ok tuple will be retuned by the default `with` behaviour

     

       17
       17
       +
           with {:error, :not_found} <- cache_result,

     

       18
       18
       +
                {:ok, identity} <- do_resolve(identifier),

     

       19
       19
       +
                identity <- Cache.insert(identity) do

     

       20
       20
       +
             {:ok, identity}

     

       21
       21
       +
           end

     

       22
       22
       +
         end

     

       23
       23
       +
       

     

       24
       24
       +
         @spec do_resolve(identity :: String.t()) ::

     

       25
       25
       +
                 {:ok, Identity.t()}

     

       26
       26
       +
                 | {:error, :handle_mismatch}

     

       27
       27
       +
                 | {:error, any()}

     

       28
       28
       +
         defp do_resolve("did:" <> _ = did) do

     

       29
       29
       +
           with {:ok, document} <- DID.resolve(did),

     

       30
       30
       +
                :ok <- DIDDocument.validate_for_atproto(document, did) do

     

       31
       31
       +
             with handle when not is_nil(handle) <- DIDDocument.get_atproto_handle(document),

     

       32
       32
       +
                  {:ok, handle_did} <- Handle.resolve(handle, @handle_strategy),

     

       33
       33
       +
                  true <- handle_did == did do

     

       34
       34
       +
               {:ok, Identity.new(did, handle, document)}

     

       35
       35
       +
             else

     

       36
       36
       +
               # Not having a handle, while a little un-ergonomic, is totally valid.

     

       37
       37
       +
               nil -> {:ok, Identity.new(did, nil, document)}

     

       38
       38
       +
               false -> {:error, :handle_mismatch}

     

       39
       39
       +
               e -> e

     

       40
       40
       +
             end

     

       41
       41
       +
           end

     

       42
       42
       +
         end

     

       43
       43
       +
       

     

       44
       44
       +
         defp do_resolve(handle) do

     

       45
       45
       +
           with {:ok, did} <- Handle.resolve(handle, @handle_strategy),

     

       46
       46
       +
                {:ok, document} <- DID.resolve(did),

     

       47
       47
       +
                did_handle when not is_nil(handle) <- DIDDocument.get_atproto_handle(document),

     

       48
       48
       +
                true <- did_handle == handle do

     

       49
       49
       +
             {:ok, Identity.new(did, handle, document)}

     

       50
       50
       +
           else

     

       51
       51
       +
             nil -> {:error, :handle_mismatch}

     

       52
       52
       +
             false -> {:error, :handle_mismatch}

     

       53
       53
       +
             e -> e

     

       54
       54
       +
           end

     

       55
       55
       +
         end

     

       56
       56
       +
       end

+264

lib/atex/lexicon/schema.ex

···

       1
       1
       +
       defmodule Atex.Lexicon.Schema do

     

       2
       2
       +
         import Peri

     

       3
       3
       +
       

     

       4
       4
       +
         defschema :lexicon, %{

     

       5
       5
       +
           lexicon: {:required, {:literal, 1}},

     

       6
       6
       +
           id: {:required, {:string, {:regex, Atex.NSID.re()}}},

     

       7
       7
       +
           revision: {:integer, {:gte, 0}},

     

       8
       8
       +
           description: :string,

     

       9
       9
       +
           defs: {

     

       10
       10
       +
             :required,

     

       11
       11
       +
             {:schema,

     

       12
       12
       +
              %{

     

       13
       13
       +
                main:

     

       14
       14
       +
                  {:oneof,

     

       15
       15
       +
                   [

     

       16
       16
       +
                     get_schema(:record),

     

       17
       17
       +
                     get_schema(:query),

     

       18
       18
       +
                     get_schema(:procedure),

     

       19
       19
       +
                     get_schema(:subscription),

     

       20
       20
       +
                     get_schema(:user_types)

     

       21
       21
       +
                   ]}

     

       22
       22
       +
              }, {:additional_keys, get_schema(:user_types)}}

     

       23
       23
       +
           }

     

       24
       24
       +
         }

     

       25
       25
       +
       

     

       26
       26
       +
         defschema :record, %{

     

       27
       27
       +
           type: {:required, {:literal, "record"}},

     

       28
       28
       +
           description: :string,

     

       29
       29
       +
           # TODO: constraint

     

       30
       30
       +
           key: {:required, :string},

     

       31
       31
       +
           record: {:required, get_schema(:object)}

     

       32
       32
       +
         }

     

       33
       33
       +
       

     

       34
       34
       +
         defschema :query, %{

     

       35
       35
       +
           type: {:required, {:literal, "query"}},

     

       36
       36
       +
           description: :string,

     

       37
       37
       +
           parameters: get_schema(:parameters),

     

       38
       38
       +
           output: get_schema(:body),

     

       39
       39
       +
           errors: {:list, get_schema(:error)}

     

       40
       40
       +
         }

     

       41
       41
       +
       

     

       42
       42
       +
         defschema :procedure, %{

     

       43
       43
       +
           type: {:required, {:literal, "procedure"}},

     

       44
       44
       +
           description: :string,

     

       45
       45
       +
           parameters: get_schema(:parameters),

     

       46
       46
       +
           input: get_schema(:body),

     

       47
       47
       +
           output: get_schema(:body),

     

       48
       48
       +
           errors: {:list, get_schema(:error)}

     

       49
       49
       +
         }

     

       50
       50
       +
       

     

       51
       51
       +
         defschema :subscription, %{

     

       52
       52
       +
           type: {:required, {:literal, "subscription"}},

     

       53
       53
       +
           description: :string,

     

       54
       54
       +
           parameters: get_schema(:parameters),

     

       55
       55
       +
           message: %{

     

       56
       56
       +
             description: :string,

     

       57
       57
       +
             schema: {:oneof, [get_schema(:object), get_schema(:ref_variant)]}

     

       58
       58
       +
           },

     

       59
       59
       +
           errors: {:list, get_schema(:error)}

     

       60
       60
       +
         }

     

       61
       61
       +
       

     

       62
       62
       +
         defschema :parameters, %{

     

       63
       63
       +
           type: {:required, {:literal, "params"}},

     

       64
       64
       +
           description: :string,

     

       65
       65
       +
           # required: {{:list, :string}, {:default, []}},

     

       66
       66
       +
           required: {:list, :string},

     

       67
       67
       +
           properties:

     

       68
       68
       +
             {:required, {:map, {:either, {get_schema(:primitive), get_schema(:primitive_array)}}}}

     

       69
       69
       +
         }

     

       70
       70
       +
       

     

       71
       71
       +
         defschema :body, %{

     

       72
       72
       +
           description: :string,

     

       73
       73
       +
           encoding: {:required, :string},

     

       74
       74
       +
           schema: {:oneof, [get_schema(:object), get_schema(:ref_variant)]}

     

       75
       75
       +
         }

     

       76
       76
       +
       

     

       77
       77
       +
         defschema :error, %{

     

       78
       78
       +
           name: {:required, :string},

     

       79
       79
       +
           description: :string

     

       80
       80
       +
         }

     

       81
       81
       +
       

     

       82
       82
       +
         defschema :user_types,

     

       83
       83
       +
                   {:oneof,

     

       84
       84
       +
                    [

     

       85
       85
       +
                      get_schema(:blob),

     

       86
       86
       +
                      get_schema(:array),

     

       87
       87
       +
                      get_schema(:token),

     

       88
       88
       +
                      get_schema(:object),

     

       89
       89
       +
                      get_schema(:boolean),

     

       90
       90
       +
                      get_schema(:integer),

     

       91
       91
       +
                      get_schema(:string),

     

       92
       92
       +
                      get_schema(:bytes),

     

       93
       93
       +
                      get_schema(:cid_link),

     

       94
       94
       +
                      get_schema(:unknown)

     

       95
       95
       +
                    ]}

     

       96
       96
       +
       

     

       97
       97
       +
         # General types

     

       98
       98
       +
       

     

       99
       99
       +
         @ref_value {:string,

     

       100
       100
       +
          {

     

       101
       101
       +
            :regex,

     

       102
       102
       +
            # TODO: minlength 1

     

       103
       103
       +
            ~r/^(?=.)(?:[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z]{0,61}[a-zA-Z])?))?(?:#[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)?$/

     

       104
       104
       +
          }}

     

       105
       105
       +
       

     

       106
       106
       +
         @positive_int {:integer, {:gte, 0}}

     

       107
       107
       +
         @nonzero_positive_int {:integer, {:gt, 0}}

     

       108
       108
       +
       

     

       109
       109
       +
         defschema :ref_variant, {:oneof, [get_schema(:ref), get_schema(:ref_union)]}

     

       110
       110
       +
       

     

       111
       111
       +
         defschema :ref, %{

     

       112
       112
       +
           type: {:required, {:literal, "ref"}},

     

       113
       113
       +
           description: :string,

     

       114
       114
       +
           ref: {:required, @ref_value}

     

       115
       115
       +
         }

     

       116
       116
       +
       

     

       117
       117
       +
         defschema :ref_union, %{

     

       118
       118
       +
           type: {:required, {:literal, "union"}},

     

       119
       119
       +
           description: :string,

     

       120
       120
       +
           refs: {:required, {:list, @ref_value}}

     

       121
       121
       +
         }

     

       122
       122
       +
       

     

       123
       123
       +
         defschema :array, %{

     

       124
       124
       +
           type: {:required, {:literal, "array"}},

     

       125
       125
       +
           description: :string,

     

       126
       126
       +
           items:

     

       127
       127
       +
             {:required,

     

       128
       128
       +
              {:oneof,

     

       129
       129
       +
               [get_schema(:primitive), get_schema(:ipld), get_schema(:blob), get_schema(:ref_variant)]}},

     

       130
       130
       +
           maxLength: @positive_int,

     

       131
       131
       +
           minLength: @positive_int

     

       132
       132
       +
         }

     

       133
       133
       +
       

     

       134
       134
       +
         defschema :primitive_array, %{

     

       135
       135
       +
           type: {:required, {:literal, "array"}},

     

       136
       136
       +
           description: :string,

     

       137
       137
       +
           items: {:required, get_schema(:primitive)},

     

       138
       138
       +
           maxLength: @positive_int,

     

       139
       139
       +
           minLength: @positive_int

     

       140
       140
       +
         }

     

       141
       141
       +
       

     

       142
       142
       +
         defschema :object, %{

     

       143
       143
       +
           type: {:required, {:literal, "object"}},

     

       144
       144
       +
           description: :string,

     

       145
       145
       +
           # required: {{:list, :string}, {:default, []}},

     

       146
       146
       +
           # nullable: {{:list, :string}, {:default, []}},

     

       147
       147
       +
           required: {:list, :string},

     

       148
       148
       +
           nullable: {:list, :string},

     

       149
       149
       +
           properties:

     

       150
       150
       +
             {:required,

     

       151
       151
       +
              {:map,

     

       152
       152
       +
               {:oneof,

     

       153
       153
       +
                [

     

       154
       154
       +
                  get_schema(:ref_variant),

     

       155
       155
       +
                  get_schema(:ipld),

     

       156
       156
       +
                  get_schema(:array),

     

       157
       157
       +
                  get_schema(:blob),

     

       158
       158
       +
                  get_schema(:primitive)

     

       159
       159
       +
                ]}}}

     

       160
       160
       +
         }

     

       161
       161
       +
       

     

       162
       162
       +
         defschema :primitive,

     

       163
       163
       +
                   {:oneof,

     

       164
       164
       +
                    [

     

       165
       165
       +
                      get_schema(:boolean),

     

       166
       166
       +
                      get_schema(:integer),

     

       167
       167
       +
                      get_schema(:string),

     

       168
       168
       +
                      get_schema(:unknown)

     

       169
       169
       +
                    ]}

     

       170
       170
       +
       

     

       171
       171
       +
         defschema :ipld, {:oneof, [get_schema(:bytes), get_schema(:cid_link)]}

     

       172
       172
       +
       

     

       173
       173
       +
         defschema :blob, %{

     

       174
       174
       +
           type: {:required, {:literal, "blob"}},

     

       175
       175
       +
           description: :string,

     

       176
       176
       +
           accept: {:list, :string},

     

       177
       177
       +
           maxSize: @positive_int

     

       178
       178
       +
         }

     

       179
       179
       +
       

     

       180
       180
       +
         defschema :boolean, %{

     

       181
       181
       +
           type: {:required, {:literal, "boolean"}},

     

       182
       182
       +
           description: :string,

     

       183
       183
       +
           default: :boolean,

     

       184
       184
       +
           const: :boolean

     

       185
       185
       +
         }

     

       186
       186
       +
       

     

       187
       187
       +
         defschema :bytes, %{

     

       188
       188
       +
           type: {:required, {:literal, "bytes"}},

     

       189
       189
       +
           description: :string,

     

       190
       190
       +
           maxLength: @positive_int,

     

       191
       191
       +
           minLength: @positive_int

     

       192
       192
       +
         }

     

       193
       193
       +
       

     

       194
       194
       +
         defschema :cid_link, %{

     

       195
       195
       +
           type: {:required, {:literal, "cid-link"}},

     

       196
       196
       +
           description: :string

     

       197
       197
       +
         }

     

       198
       198
       +
       

     

       199
       199
       +
         @string_type {:required, {:literal, "string"}}

     

       200
       200
       +
       

     

       201
       201
       +
         defschema :string,

     

       202
       202
       +
                   {:either,

     

       203
       203
       +
                    {

     

       204
       204
       +
                      # Formatted

     

       205
       205
       +
                      %{

     

       206
       206
       +
                        type: @string_type,

     

       207
       207
       +
                        format:

     

       208
       208
       +
                          {:required,

     

       209
       209
       +
                           {:enum,

     

       210
       210
       +
                            [

     

       211
       211
       +
                              "at-identifier",

     

       212
       212
       +
                              "at-uri",

     

       213
       213
       +
                              "cid",

     

       214
       214
       +
                              "datetime",

     

       215
       215
       +
                              "did",

     

       216
       216
       +
                              "handle",

     

       217
       217
       +
                              "language",

     

       218
       218
       +
                              "nsid",

     

       219
       219
       +
                              "record-key",

     

       220
       220
       +
                              "tid",

     

       221
       221
       +
                              "uri"

     

       222
       222
       +
                            ]}},

     

       223
       223
       +
                        description: :string,

     

       224
       224
       +
                        default: :string,

     

       225
       225
       +
                        const: :string,

     

       226
       226
       +
                        enum: {:list, :string},

     

       227
       227
       +
                        knownValues: {:list, :string}

     

       228
       228
       +
                      },

     

       229
       229
       +
                      # Unformatted

     

       230
       230
       +
                      %{

     

       231
       231
       +
                        type: @string_type,

     

       232
       232
       +
                        description: :string,

     

       233
       233
       +
                        default: :string,

     

       234
       234
       +
                        const: :string,

     

       235
       235
       +
                        enum: {:list, :string},

     

       236
       236
       +
                        knownValues: {:list, :string},

     

       237
       237
       +
                        format: {:literal, nil},

     

       238
       238
       +
                        maxLength: @nonzero_positive_int,

     

       239
       239
       +
                        minLength: @nonzero_positive_int,

     

       240
       240
       +
                        maxGraphemes: @nonzero_positive_int,

     

       241
       241
       +
                        minGraphemes: @nonzero_positive_int

     

       242
       242
       +
                      }

     

       243
       243
       +
                    }}

     

       244
       244
       +
       

     

       245
       245
       +
         defschema :integer, %{

     

       246
       246
       +
           type: {:required, {:literal, "integer"}},

     

       247
       247
       +
           description: :string,

     

       248
       248
       +
           default: @positive_int,

     

       249
       249
       +
           const: @positive_int,

     

       250
       250
       +
           enum: {:list, @positive_int},

     

       251
       251
       +
           maximum: @positive_int,

     

       252
       252
       +
           minimum: @positive_int

     

       253
       253
       +
         }

     

       254
       254
       +
       

     

       255
       255
       +
         defschema :token, %{

     

       256
       256
       +
           type: {:required, {:literal, "token"}},

     

       257
       257
       +
           description: :string

     

       258
       258
       +
         }

     

       259
       259
       +
       

     

       260
       260
       +
         defschema :unknown, %{

     

       261
       261
       +
           type: {:required, {:literal, "unknown"}},

     

       262
       262
       +
           description: :string

     

       263
       263
       +
         }

     

       264
       264
       +
       end

+52

lib/atex/lexicon/validators/array.ex

···

       1
       1
       +
       defmodule Atex.Lexicon.Validators.Array do

     

       2
       2
       +
         @type option() :: {:min_length, non_neg_integer()} | {:max_length, non_neg_integer()}

     

       3
       3
       +
       

     

       4
       4
       +
         @option_keys [:min_length, :max_length]

     

       5
       5
       +
       

     

       6
       6
       +
         # Needs type input

     

       7
       7
       +
         @spec validate(term(), Peri.schema_def(), list(option())) :: Peri.validation_result()

     

       8
       8
       +
         def validate(value, inner_type, options) when is_list(value) do

     

       9
       9
       +
           # TODO: validate inner_type with Peri to make sure it's correct?

     

       10
       10
       +
       

     

       11
       11
       +
           options

     

       12
       12
       +
           |> Keyword.validate!(min_length: nil, max_length: nil)

     

       13
       13
       +
           |> Stream.map(&validate_option(value, &1))

     

       14
       14
       +
           |> Enum.find(:ok, fn x -> x != :ok end)

     

       15
       15
       +
           |> case do

     

       16
       16
       +
             :ok ->

     

       17
       17
       +
               value

     

       18
       18
       +
               |> Stream.map(&Peri.validate(inner_type, &1))

     

       19
       19
       +
               |> Enum.find({:ok, nil}, fn

     

       20
       20
       +
                 {:ok, _} -> false

     

       21
       21
       +
                 {:error, _} -> true

     

       22
       22
       +
               end)

     

       23
       23
       +
               |> case do

     

       24
       24
       +
                 {:ok, _} -> :ok

     

       25
       25
       +
                 e -> e

     

       26
       26
       +
               end

     

       27
       27
       +
       

     

       28
       28
       +
             e ->

     

       29
       29
       +
               e

     

       30
       30
       +
           end

     

       31
       31
       +
         end

     

       32
       32
       +
       

     

       33
       33
       +
         def validate(_inner_type, value, _options),

     

       34
       34
       +
           do: {:error, "expected type of `array`, received #{value}", [expected: :array, actual: value]}

     

       35
       35
       +
       

     

       36
       36
       +
         @spec validate_option(list(), option()) :: Peri.validation_result()

     

       37
       37
       +
         defp validate_option(value, option)

     

       38
       38
       +
       

     

       39
       39
       +
         defp validate_option(_value, {option, nil}) when option in @option_keys, do: :ok

     

       40
       40
       +
       

     

       41
       41
       +
         defp validate_option(value, {:min_length, expected}) when length(value) >= expected,

     

       42
       42
       +
           do: :ok

     

       43
       43
       +
       

     

       44
       44
       +
         defp validate_option(value, {:min_length, expected}) when length(value) < expected,

     

       45
       45
       +
           do: {:error, "should have a minimum length of #{expected}", [length: expected]}

     

       46
       46
       +
       

     

       47
       47
       +
         defp validate_option(value, {:max_length, expected}) when length(value) <= expected,

     

       48
       48
       +
           do: :ok

     

       49
       49
       +
       

     

       50
       50
       +
         defp validate_option(value, {:max_length, expected}) when length(value) > expected,

     

       51
       51
       +
           do: {:error, "should have a maximum length of #{expected}", [length: expected]}

     

       52
       52
       +
       end

+32

lib/atex/lexicon/validators/bytes.ex

···

       1
       1
       +
       defmodule Atex.Lexicon.Validators.Bytes do

     

       2
       2
       +
         @type option() :: {:min_length, pos_integer()} | {:max_length, pos_integer()}

     

       3
       3
       +
       

     

       4
       4
       +
         @option_keys [:min_length, :max_length]

     

       5
       5
       +
       

     

       6
       6
       +
         @spec validate(term(), list(option())) :: Peri.validation_result()

     

       7
       7
       +
         def validate(value, options) when is_binary(value) do

     

       8
       8
       +
           case Base.decode64(value, padding: false) do

     

       9
       9
       +
             {:ok, bytes} ->

     

       10
       10
       +
               options

     

       11
       11
       +
               |> Keyword.validate!(min_length: nil, max_length: nil)

     

       12
       12
       +
               |> Stream.map(&validate_option(bytes, &1))

     

       13
       13
       +
               |> Enum.find(:ok, fn x -> x !== :ok end)

     

       14
       14
       +
       

     

       15
       15
       +
             :error ->

     

       16
       16
       +
               {:error, "expected valid base64 encoded bytes", []}

     

       17
       17
       +
           end

     

       18
       18
       +
         end

     

       19
       19
       +
       

     

       20
       20
       +
         def validate(value, _options),

     

       21
       21
       +
           do:

     

       22
       22
       +
             {:error, "expected valid base64 encoded bytes, received #{value}",

     

       23
       23
       +
              [expected: :bytes, actual: value]}

     

       24
       24
       +
       

     

       25
       25
       +
         defp validate_option(_value, {option, nil}) when option in @option_keys, do: :ok

     

       26
       26
       +
       

     

       27
       27
       +
         defp validate_option(value, {:min_length, expected}) when byte_size(value) < expected,

     

       28
       28
       +
           do: {:error, "should have a minimum byte length of #{expected}", [length: expected]}

     

       29
       29
       +
       

     

       30
       30
       +
         defp validate_option(value, {:max_length, expected}) when byte_size(value) <= expected,

     

       31
       31
       +
           do: :ok

     

       32
       32
       +
       end

+38

lib/atex/lexicon/validators/integer.ex

···

       1
       1
       +
       defmodule Atex.Lexicon.Validators.Integer do

     

       2
       2
       +
         @type option() ::

     

       3
       3
       +
                 {:minimum, integer()}

     

       4
       4
       +
                 | {:maximum, integer()}

     

       5
       5
       +
       

     

       6
       6
       +
         @option_keys [:minimum, :maximum]

     

       7
       7
       +
       

     

       8
       8
       +
         @spec validate(term(), list(option())) :: Peri.validation_result()

     

       9
       9
       +
         def validate(value, options) when is_integer(value) do

     

       10
       10
       +
           options

     

       11
       11
       +
           |> Keyword.validate!(

     

       12
       12
       +
             minimum: nil,

     

       13
       13
       +
             maximum: nil

     

       14
       14
       +
           )

     

       15
       15
       +
           |> Stream.map(&validate_option(value, &1))

     

       16
       16
       +
           |> Enum.find(:ok, fn x -> x != :ok end)

     

       17
       17
       +
         end

     

       18
       18
       +
       

     

       19
       19
       +
         def validate(value, _options),

     

       20
       20
       +
           do:

     

       21
       21
       +
             {:error, "expected type of `integer`, received #{value}",

     

       22
       22
       +
              [expected: :integer, actual: value]}

     

       23
       23
       +
       

     

       24
       24
       +
         @spec validate_option(integer(), option()) :: Peri.validation_result()

     

       25
       25
       +
         defp validate_option(value, option)

     

       26
       26
       +
       

     

       27
       27
       +
         defp validate_option(_value, {option, nil}) when option in @option_keys, do: :ok

     

       28
       28
       +
       

     

       29
       29
       +
         defp validate_option(value, {:minimum, expected}) when value >= expected, do: :ok

     

       30
       30
       +
       

     

       31
       31
       +
         defp validate_option(value, {:minimum, expected}) when value < expected,

     

       32
       32
       +
           do: {:error, "", [value: expected]}

     

       33
       33
       +
       

     

       34
       34
       +
         defp validate_option(value, {:maximum, expected}) when value <= expected, do: :ok

     

       35
       35
       +
       

     

       36
       36
       +
         defp validate_option(value, {:maximum, expected}) when value > expected,

     

       37
       37
       +
           do: {:error, "", [value: expected]}

     

       38
       38
       +
       end

+134

lib/atex/lexicon/validators/string.ex

···

       1
       1
       +
       defmodule Atex.Lexicon.Validators.String do

     

       2
       2
       +
         alias Atex.Lexicon.Validators

     

       3
       3
       +
       

     

       4
       4
       +
         @type option() ::

     

       5
       5
       +
                 {:format, String.t()}

     

       6
       6
       +
                 | {:min_length, non_neg_integer()}

     

       7
       7
       +
                 | {:max_length, non_neg_integer()}

     

       8
       8
       +
                 | {:min_graphemes, non_neg_integer()}

     

       9
       9
       +
                 | {:max_graphemes, non_neg_integer()}

     

       10
       10
       +
       

     

       11
       11
       +
         @option_keys [

     

       12
       12
       +
           :format,

     

       13
       13
       +
           :min_length,

     

       14
       14
       +
           :max_length,

     

       15
       15
       +
           :min_graphemes,

     

       16
       16
       +
           :max_graphemes

     

       17
       17
       +
         ]

     

       18
       18
       +
       

     

       19
       19
       +
         @record_key_re ~r"^[a-zA-Z0-9.-_:~]$"

     

       20
       20
       +
       

     

       21
       21
       +
         @spec validate(term(), list(option())) :: Peri.validation_result()

     

       22
       22
       +
         def validate(value, options) when is_binary(value) do

     

       23
       23
       +
           options

     

       24
       24
       +
           |> Keyword.validate!(

     

       25
       25
       +
             format: nil,

     

       26
       26
       +
             min_length: nil,

     

       27
       27
       +
             max_length: nil,

     

       28
       28
       +
             min_graphemes: nil,

     

       29
       29
       +
             max_graphemes: nil

     

       30
       30
       +
           )

     

       31
       31
       +
           # Stream so we early exit at the first error.

     

       32
       32
       +
           |> Stream.map(&validate_option(value, &1))

     

       33
       33
       +
           |> Enum.find(:ok, fn x -> x != :ok end)

     

       34
       34
       +
         end

     

       35
       35
       +
       

     

       36
       36
       +
         def validate(value, _options),

     

       37
       37
       +
           do:

     

       38
       38
       +
             {:error, "expected type of `string`, received #{value}", [expected: :string, actual: value]}

     

       39
       39
       +
       

     

       40
       40
       +
         @spec validate_option(String.t(), option()) :: Peri.validation_result()

     

       41
       41
       +
         defp validate_option(value, option)

     

       42
       42
       +
       

     

       43
       43
       +
         defp validate_option(_value, {option, nil}) when option in @option_keys, do: :ok

     

       44
       44
       +
       

     

       45
       45
       +
         defp validate_option(value, {:format, "at-identifier"}),

     

       46
       46
       +
           do:

     

       47
       47
       +
             Validators.boolean_validate(

     

       48
       48
       +
               Atex.DID.match?(value) or Atex.Handle.match?(value),

     

       49
       49
       +
               "should be a valid DID or handle"

     

       50
       50
       +
             )

     

       51
       51
       +
       

     

       52
       52
       +
         defp validate_option(value, {:format, "at-uri"}),

     

       53
       53
       +
           do: Validators.boolean_validate(Atex.AtURI.match?(value), "should be a valid at:// URI")

     

       54
       54
       +
       

     

       55
       55
       +
         defp validate_option(value, {:format, "cid"}) do

     

       56
       56
       +
           # TODO: is there a regex provided by the lexicon docs/somewhere?

     

       57
       57
       +
           try do

     

       58
       58
       +
             Multiformats.CID.decode(value)

     

       59
       59
       +
             :ok

     

       60
       60
       +
           rescue

     

       61
       61
       +
             _ -> {:error, "should be a valid CID", []}

     

       62
       62
       +
           end

     

       63
       63
       +
         end

     

       64
       64
       +
       

     

       65
       65
       +
         defp validate_option(value, {:format, "datetime"}) do

     

       66
       66
       +
           # NaiveDateTime is used over DateTime because the result isn't actually

     

       67
       67
       +
           # being used, so we don't need to include a calendar library just for this.

     

       68
       68
       +
           case NaiveDateTime.from_iso8601(value) do

     

       69
       69
       +
             {:ok, _} -> :ok

     

       70
       70
       +
             {:error, _} -> {:error, "should be a valid datetime", []}

     

       71
       71
       +
           end

     

       72
       72
       +
         end

     

       73
       73
       +
       

     

       74
       74
       +
         defp validate_option(value, {:format, "did"}),

     

       75
       75
       +
           do: Validators.boolean_validate(Atex.DID.match?(value), "should be a valid DID")

     

       76
       76
       +
       

     

       77
       77
       +
         defp validate_option(value, {:format, "handle"}),

     

       78
       78
       +
           do: Validators.boolean_validate(Atex.Handle.match?(value), "should be a valid handle")

     

       79
       79
       +
       

     

       80
       80
       +
         defp validate_option(value, {:format, "nsid"}),

     

       81
       81
       +
           do: Validators.boolean_validate(Atex.NSID.match?(value), "should be a valid NSID")

     

       82
       82
       +
       

     

       83
       83
       +
         defp validate_option(value, {:format, "tid"}),

     

       84
       84
       +
           do: Validators.boolean_validate(Atex.TID.match?(value), "should be a valid TID")

     

       85
       85
       +
       

     

       86
       86
       +
         defp validate_option(value, {:format, "record-key"}),

     

       87
       87
       +
           do:

     

       88
       88
       +
             Validators.boolean_validate(

     

       89
       89
       +
               Regex.match?(@record_key_re, value),

     

       90
       90
       +
               "should be a valid record key"

     

       91
       91
       +
             )

     

       92
       92
       +
       

     

       93
       93
       +
         defp validate_option(value, {:format, "uri"}) do

     

       94
       94
       +
           case URI.new(value) do

     

       95
       95
       +
             {:ok, _} -> :ok

     

       96
       96
       +
             {:error, _} -> {:error, "should be a valid URI", []}

     

       97
       97
       +
           end

     

       98
       98
       +
         end

     

       99
       99
       +
       

     

       100
       100
       +
         defp validate_option(value, {:format, "language"}) do

     

       101
       101
       +
           case Cldr.LanguageTag.parse(value) do

     

       102
       102
       +
             {:ok, _} -> :ok

     

       103
       103
       +
             {:error, _} -> {:error, "should be a valid BCP 47 language tag", []}

     

       104
       104
       +
           end

     

       105
       105
       +
         end

     

       106
       106
       +
       

     

       107
       107
       +
         defp validate_option(value, {:min_length, expected}) when byte_size(value) >= expected,

     

       108
       108
       +
           do: :ok

     

       109
       109
       +
       

     

       110
       110
       +
         defp validate_option(value, {:min_length, expected}) when byte_size(value) < expected,

     

       111
       111
       +
           do: {:error, "should have a minimum byte length of #{expected}", [length: expected]}

     

       112
       112
       +
       

     

       113
       113
       +
         defp validate_option(value, {:max_length, expected}) when byte_size(value) <= expected,

     

       114
       114
       +
           do: :ok

     

       115
       115
       +
       

     

       116
       116
       +
         defp validate_option(value, {:max_length, expected}) when byte_size(value) > expected,

     

       117
       117
       +
           do: {:error, "should have a maximum byte length of #{expected}", [length: expected]}

     

       118
       118
       +
       

     

       119
       119
       +
         defp validate_option(value, {:min_graphemes, expected}),

     

       120
       120
       +
           do:

     

       121
       121
       +
             Validators.boolean_validate(

     

       122
       122
       +
               String.length(value) >= expected,

     

       123
       123
       +
               "should have a minimum length of #{expected}",

     

       124
       124
       +
               length: expected

     

       125
       125
       +
             )

     

       126
       126
       +
       

     

       127
       127
       +
         defp validate_option(value, {:max_graphemes, expected}),

     

       128
       128
       +
           do:

     

       129
       129
       +
             Validators.boolean_validate(

     

       130
       130
       +
               String.length(value) <= expected,

     

       131
       131
       +
               "should have a maximum length of #{expected}",

     

       132
       132
       +
               length: expected

     

       133
       133
       +
             )

     

       134
       134
       +
       end

+106

lib/atex/lexicon/validators.ex

···

       1
       1
       +
       defmodule Atex.Lexicon.Validators do

     

       2
       2
       +
         alias Atex.Lexicon.Validators

     

       3
       3
       +
       

     

       4
       4
       +
         @type blob_option() :: {:accept, list(String.t())} | {:max_size, pos_integer()}

     

       5
       5
       +
       

     

       6
       6
       +
         @type blob() ::

     

       7
       7
       +
                 %{

     

       8
       8
       +
                   "$type": String.t(),

     

       9
       9
       +
                   ref: %{"$link": String.t()},

     

       10
       10
       +
                   mimeType: String.t(),

     

       11
       11
       +
                   size: integer()

     

       12
       12
       +
                 }

     

       13
       13
       +
                 | %{

     

       14
       14
       +
                     cid: String.t(),

     

       15
       15
       +
                     mimeType: String.t()

     

       16
       16
       +
                   }

     

       17
       17
       +
       

     

       18
       18
       +
         @type cid_link() :: %{"$link": String.t()}

     

       19
       19
       +
       

     

       20
       20
       +
         @type bytes() :: %{"$bytes": binary()}

     

       21
       21
       +
       

     

       22
       22
       +
         @spec string(list(Validators.String.option())) :: Peri.custom_def()

     

       23
       23
       +
         def string(options \\ []), do: {:custom, {Validators.String, :validate, [options]}}

     

       24
       24
       +
       

     

       25
       25
       +
         @spec integer(list(Validators.Integer.option())) :: Peri.custom_def()

     

       26
       26
       +
         def integer(options \\ []), do: {:custom, {Validators.Integer, :validate, [options]}}

     

       27
       27
       +
       

     

       28
       28
       +
         @spec array(Peri.schema_def(), list(Validators.Array.option())) :: Peri.custom_def()

     

       29
       29
       +
         def array(inner_type, options \\ []) do

     

       30
       30
       +
           {:custom, {Validators.Array, :validate, [inner_type, options]}}

     

       31
       31
       +
         end

     

       32
       32
       +
       

     

       33
       33
       +
         @spec blob(list(blob_option())) :: Peri.schema_def()

     

       34
       34
       +
         def blob(options \\ []) do

     

       35
       35
       +
           options = Keyword.validate!(options, accept: nil, max_size: nil)

     

       36
       36
       +
           accept = Keyword.get(options, :accept)

     

       37
       37
       +
           max_size = Keyword.get(options, :max_size)

     

       38
       38
       +
       

     

       39
       39
       +
           mime_type =

     

       40
       40
       +
             {:required,

     

       41
       41
       +
              if(accept,

     

       42
       42
       +
                do: {:string, {:regex, strings_to_re(accept)}},

     

       43
       43
       +
                else: {:string, {:regex, ~r"^.+/.+$"}}

     

       44
       44
       +
              )}

     

       45
       45
       +
       

     

       46
       46
       +
           {

     

       47
       47
       +
             :either,

     

       48
       48
       +
             {

     

       49
       49
       +
               # Newer blobs

     

       50
       50
       +
               %{

     

       51
       51
       +
                 "$type": {:required, {:literal, "blob"}},

     

       52
       52
       +
                 ref: {:required, %{"$link": {:required, :string}}},

     

       53
       53
       +
                 mimeType: mime_type,

     

       54
       54
       +
                 size: {:required, if(max_size != nil, do: {:integer, {:lte, max_size}}, else: :integer)}

     

       55
       55
       +
               },

     

       56
       56
       +
               # Old deprecated blobs

     

       57
       57
       +
               %{

     

       58
       58
       +
                 cid: {:required, :string},

     

       59
       59
       +
                 mimeType: mime_type

     

       60
       60
       +
               }

     

       61
       61
       +
             }

     

       62
       62
       +
           }

     

       63
       63
       +
         end

     

       64
       64
       +
       

     

       65
       65
       +
         @spec bytes(list(Validators.Bytes.option())) :: Peri.schema()

     

       66
       66
       +
         def bytes(options \\ []) do

     

       67
       67
       +
           options = Keyword.validate!(options, min_length: nil, max_length: nil)

     

       68
       68
       +
       

     

       69
       69
       +
           %{

     

       70
       70
       +
             "$bytes":

     

       71
       71
       +
               {:required,

     

       72
       72
       +
                {{:custom, {Validators.Bytes, :validate, [options]}}, {:transform, &Base.decode64!/1}}}

     

       73
       73
       +
           }

     

       74
       74
       +
         end

     

       75
       75
       +
       

     

       76
       76
       +
         # TODO: see what atcute validators expect

     

       77
       77
       +
         # TODO: cid validation?

     

       78
       78
       +
         def cid_link() do

     

       79
       79
       +
           %{

     

       80
       80
       +
             "$link": {:required, :string}

     

       81
       81
       +
           }

     

       82
       82
       +
         end

     

       83
       83
       +
       

     

       84
       84
       +
         @spec lazy_ref(module(), atom()) :: Peri.schema()

     

       85
       85
       +
         def lazy_ref(module, schema_name) do

     

       86
       86
       +
           {:custom, {module, schema_name, []}}

     

       87
       87
       +
         end

     

       88
       88
       +
       

     

       89
       89
       +
         @spec boolean_validate(boolean(), String.t(), keyword() | map()) ::

     

       90
       90
       +
                 Peri.validation_result()

     

       91
       91
       +
         def boolean_validate(success?, error_message, context \\ []) do

     

       92
       92
       +
           if success? do

     

       93
       93
       +
             :ok

     

       94
       94
       +
           else

     

       95
       95
       +
             {:error, error_message, context}

     

       96
       96
       +
           end

     

       97
       97
       +
         end

     

       98
       98
       +
       

     

       99
       99
       +
         @spec strings_to_re(list(String.t())) :: Regex.t()

     

       100
       100
       +
         defp strings_to_re(strings) do

     

       101
       101
       +
           strings

     

       102
       102
       +
           |> Enum.map(&String.replace(&1, "*", ".+"))

     

       103
       103
       +
           |> Enum.join("|")

     

       104
       104
       +
           |> then(&~r/^(#{&1})$/)

     

       105
       105
       +
         end

     

       106
       106
       +
       end

+669

lib/atex/lexicon.ex

···

       1
       1
       +
       defmodule Atex.Lexicon do

     

       2
       2
       +
         alias Atex.Lexicon.Validators

     

       3
       3
       +
       

     

       4
       4
       +
         defmacro __using__(_opts) do

     

       5
       5
       +
           quote do

     

       6
       6
       +
             import Atex.Lexicon

     

       7
       7
       +
             import Atex.Lexicon.Validators

     

       8
       8
       +
             import Peri

     

       9
       9
       +
           end

     

       10
       10
       +
         end

     

       11
       11
       +
       

     

       12
       12
       +
         @doc """

     

       13
       13
       +
         Defines a lexicon module from a JSON lexicon definition.

     

       14
       14
       +
       

     

       15
       15
       +
         The `deflexicon` macro processes the provided lexicon map (typically loaded

     

       16
       16
       +
         from a JSON file) and generates:

     

       17
       17
       +
       

     

       18
       18
       +
         - **Typespecs** for each definition, exposing a `t/0` type for the main

     

       19
       19
       +
           definition and named types for any additional definitions.

     

       20
       20
       +
         - **`Peri` schemas** via `defschema/2` for runtime validation of data.

     

       21
       21
       +
         - **Structs** for object and record definitions, with `@enforce_keys` ensuring

     

       22
       22
       +
           required fields are present.

     

       23
       23
       +
         - For **queries** and **procedures**, it creates structs for `params`,

     

       24
       24
       +
           `input`, and `output` when those sections exist in the lexicon. It also

     

       25
       25
       +
           generates a top‑level struct that aggregates `params` and `input` (when

     

       26
       26
       +
           applicable); this struct is used by the XRPC client to locate the

     

       27
       27
       +
           appropriate output struct.

     

       28
       28
       +
       

     

       29
       29
       +
         If a procedure doesn't have a schema for a JSON body specified as it's input,

     

       30
       30
       +
         the top-level struct will instead have a `raw_input` field, allowing for

     

       31
       31
       +
         miscellaneous bodies such as a binary blob.

     

       32
       32
       +
       

     

       33
       33
       +
         The generated structs also implement the `JSON.Encoder` and `Jason.Encoder`

     

       34
       34
       +
         protocols (the latter currently present for compatibility), as well as a

     

       35
       35
       +
         `from_json` function which is used to validate an input map - e.g. from a JSON

     

       36
       36
       +
         HTTP response - and turn it into a struct.

     

       37
       37
       +
       

     

       38
       38
       +
         ## Example

     

       39
       39
       +
       

     

       40
       40
       +
             deflexicon(%{

     

       41
       41
       +
               "lexicon" => 1,

     

       42
       42
       +
               "id" => "com.ovyerus.testing",

     

       43
       43
       +
               "defs" => %{

     

       44
       44
       +
                 "main" => %{

     

       45
       45
       +
                   "type" => "record",

     

       46
       46
       +
                   "key" => "tid",

     

       47
       47
       +
                   "record" => %{

     

       48
       48
       +
                     "type" => "object",

     

       49
       49
       +
                     "required" => ["foobar"],

     

       50
       50
       +
                     "properties" => %{ "foobar" => %{ "type" => "string" } }

     

       51
       51
       +
                   }

     

       52
       52
       +
                 }

     

       53
       53
       +
               }

     

       54
       54
       +
             })

     

       55
       55
       +
       

     

       56
       56
       +
         The macro expands to following code (truncated for brevity):

     

       57
       57
       +
       

     

       58
       58
       +
             @type main() :: %{required(:foobar) => String.t(), optional(:"$type") => String.t()}

     

       59
       59
       +
             @type t() :: %{required(:foobar) => String.t(), optional(:"$type") => String.t()}

     

       60
       60
       +
       

     

       61
       61
       +
             defschema(:main, %{

     

       62
       62
       +
               foobar: {:required, {:custom, {Atex.Lexicon.Validators.String, :validate, [[]]}}},

     

       63
       63
       +
               "$type": {{:literal, "com.ovyerus.testing"}, {:default, "com.ovyerus.testing"}}

     

       64
       64
       +
             })

     

       65
       65
       +
       

     

       66
       66
       +
             @enforce_keys [:foobar]

     

       67
       67
       +
             defstruct foobar: nil, "$type": "com.ovyerus.testing"

     

       68
       68
       +
       

     

       69
       69
       +
             def from_json(json) do

     

       70
       70
       +
               case apply(Com.Ovyerus.Testing, :main, [json]) do

     

       71
       71
       +
                 {:ok, map} -> {:ok, struct(__MODULE__, map)}

     

       72
       72
       +
                 err -> err

     

       73
       73
       +
               end

     

       74
       74
       +
             end

     

       75
       75
       +
       

     

       76
       76
       +
         The generated module can be used directly with `Atex.XRPC` functions, allowing

     

       77
       77
       +
         type‑safe construction of requests and automatic decoding of responses.

     

       78
       78
       +
         """

     

       79
       79
       +
         defmacro deflexicon(lexicon) do

     

       80
       80
       +
           # Better way to get the real map, without having to eval? (custom function to compose one from quoted?)

     

       81
       81
       +
           lexicon =

     

       82
       82
       +
             lexicon

     

       83
       83
       +
             |> Code.eval_quoted()

     

       84
       84
       +
             |> elem(0)

     

       85
       85
       +
             |> then(&Recase.Enumerable.atomize_keys/1)

     

       86
       86
       +
             |> then(&Atex.Lexicon.Schema.lexicon!/1)

     

       87
       87
       +
       

     

       88
       88
       +
           defs =

     

       89
       89
       +
             lexicon.defs

     

       90
       90
       +
             |> Enum.flat_map(fn {def_name, def} -> def_to_schema(lexicon.id, def_name, def) end)

     

       91
       91
       +
             |> Enum.map(fn

     

       92
       92
       +
               {schema_key, quoted_schema, quoted_type} -> {schema_key, quoted_schema, quoted_type, nil}

     

       93
       93
       +
               x -> x

     

       94
       94
       +
             end)

     

       95
       95
       +
             |> Enum.map(fn {schema_key, quoted_schema, quoted_type, quoted_struct} ->

     

       96
       96
       +
               identity_type =

     

       97
       97
       +
                 if schema_key == :main do

     

       98
       98
       +
                   quote do

     

       99
       99
       +
                     @type t() :: unquote(quoted_type)

     

       100
       100
       +
                   end

     

       101
       101
       +
                 end

     

       102
       102
       +
       

     

       103
       103
       +
               struct_def =

     

       104
       104
       +
                 if schema_key == :main do

     

       105
       105
       +
                   quoted_struct

     

       106
       106
       +
                 else

     

       107
       107
       +
                   nested_module_name =

     

       108
       108
       +
                     schema_key

     

       109
       109
       +
                     |> Recase.to_pascal()

     

       110
       110
       +
                     |> atomise()

     

       111
       111
       +
       

     

       112
       112
       +
                   quote do

     

       113
       113
       +
                     defmodule unquote({:__aliases__, [alias: false], [nested_module_name]}) do

     

       114
       114
       +
                       unquote(quoted_struct)

     

       115
       115
       +
                     end

     

       116
       116
       +
                   end

     

       117
       117
       +
                 end

     

       118
       118
       +
       

     

       119
       119
       +
               quote do

     

       120
       120
       +
                 @type unquote(Recase.to_snake(schema_key))() :: unquote(quoted_type)

     

       121
       121
       +
                 unquote(identity_type)

     

       122
       122
       +
       

     

       123
       123
       +
                 defschema unquote(Recase.to_snake(schema_key)), unquote(quoted_schema)

     

       124
       124
       +
       

     

       125
       125
       +
                 unquote(struct_def)

     

       126
       126
       +
               end

     

       127
       127
       +
             end)

     

       128
       128
       +
       

     

       129
       129
       +
           quote do

     

       130
       130
       +
             def id, do: unquote(lexicon.id)

     

       131
       131
       +
       

     

       132
       132
       +
             unquote_splicing(defs)

     

       133
       133
       +
           end

     

       134
       134
       +
         end

     

       135
       135
       +
       

     

       136
       136
       +
         # - [ ] `t()` type should be the struct in it. (add to non-main structs too?)

     

       137
       137
       +
       

     

       138
       138
       +
         @spec def_to_schema(nsid :: String.t(), def_name :: String.t(), lexicon_def :: map()) ::

     

       139
       139
       +
                 list(

     

       140
       140
       +
                   {

     

       141
       141
       +
                     key :: atom(),

     

       142
       142
       +
                     quoted_schema :: term(),

     

       143
       143
       +
                     quoted_type :: term()

     

       144
       144
       +
                   }

     

       145
       145
       +
                   | {

     

       146
       146
       +
                       key :: atom(),

     

       147
       147
       +
                       quoted_schema :: term(),

     

       148
       148
       +
                       quoted_type :: term(),

     

       149
       149
       +
                       quoted_struct :: term()

     

       150
       150
       +
                     }

     

       151
       151
       +
                 )

     

       152
       152
       +
       

     

       153
       153
       +
         defp def_to_schema(nsid, def_name, %{type: "record", record: record}) do

     

       154
       154
       +
           # TODO: record rkey format validator

     

       155
       155
       +
           type_name = Atex.NSID.canonical_name(nsid, to_string(def_name))

     

       156
       156
       +
       

     

       157
       157
       +
           record =

     

       158
       158
       +
             put_in(record, [:properties, :"$type"], %{

     

       159
       159
       +
               type: "string",

     

       160
       160
       +
               const: type_name,

     

       161
       161
       +
               default: type_name

     

       162
       162
       +
             })

     

       163
       163
       +
       

     

       164
       164
       +
           def_to_schema(nsid, def_name, record)

     

       165
       165
       +
         end

     

       166
       166
       +
       

     

       167
       167
       +
         # TODO: add struct to types

     

       168
       168
       +
         defp def_to_schema(

     

       169
       169
       +
                nsid,

     

       170
       170
       +
                def_name,

     

       171
       171
       +
                %{

     

       172
       172
       +
                  type: "object",

     

       173
       173
       +
                  properties: properties

     

       174
       174
       +
                } = def

     

       175
       175
       +
              ) do

     

       176
       176
       +
           required = Map.get(def, :required, [])

     

       177
       177
       +
           nullable = Map.get(def, :nullable, [])

     

       178
       178
       +
       

     

       179
       179
       +
           {quoted_schemas, quoted_types} =

     

       180
       180
       +
             properties

     

       181
       181
       +
             |> Enum.map(fn {key, field} ->

     

       182
       182
       +
               {quoted_schema, quoted_type} = field_to_schema(field, nsid)

     

       183
       183
       +
               string_key = to_string(key)

     

       184
       184
       +
               is_nullable = string_key in nullable

     

       185
       185
       +
               is_required = string_key in required

     

       186
       186
       +
       

     

       187
       187
       +
               quoted_schema =

     

       188
       188
       +
                 quoted_schema

     

       189
       189
       +
                 |> then(

     

       190
       190
       +
                   &if is_nullable, do: quote(do: {:either, {{:literal, nil}, unquote(&1)}}), else: &1

     

       191
       191
       +
                 )

     

       192
       192
       +
                 |> then(&if is_required, do: quote(do: {:required, unquote(&1)}), else: &1)

     

       193
       193
       +
                 |> then(&{key, &1})

     

       194
       194
       +
       

     

       195
       195
       +
               key_type = if is_required, do: :required, else: :optional

     

       196
       196
       +
       

     

       197
       197
       +
               quoted_type =

     

       198
       198
       +
                 quoted_type

     

       199
       199
       +
                 |> then(

     

       200
       200
       +
                   &if is_nullable do

     

       201
       201
       +
                     {:|, [], [&1, nil]}

     

       202
       202
       +
                   else

     

       203
       203
       +
                     &1

     

       204
       204
       +
                   end

     

       205
       205
       +
                 )

     

       206
       206
       +
                 |> then(&{{key_type, [], [key]}, &1})

     

       207
       207
       +
       

     

       208
       208
       +
               {quoted_schema, quoted_type}

     

       209
       209
       +
             end)

     

       210
       210
       +
             |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->

     

       211
       211
       +
               {[quoted_schema | schemas], [quoted_type | types]}

     

       212
       212
       +
             end)

     

       213
       213
       +
       

     

       214
       214
       +
           struct_keys =

     

       215
       215
       +
             properties

     

       216
       216
       +
             |> Enum.filter(fn {key, _} -> key !== :"$type" end)

     

       217
       217
       +
             |> Enum.map(fn

     

       218
       218
       +
               {key, %{default: default}} -> {key, default}

     

       219
       219
       +
               {key, _field} -> {key, nil}

     

       220
       220
       +
             end)

     

       221
       221
       +
             |> then(&(&1 ++ [{:"$type", if(def_name == :main, do: nsid, else: "#{nsid}##{def_name}")}]))

     

       222
       222
       +
       

     

       223
       223
       +
           enforced_keys =

     

       224
       224
       +
             properties |> Map.keys() |> Enum.filter(&(to_string(&1) in required && &1 != :"$type"))

     

       225
       225
       +
       

     

       226
       226
       +
           optional_if_nil_keys =

     

       227
       227
       +
             properties

     

       228
       228
       +
             |> Map.keys()

     

       229
       229
       +
             |> Enum.filter(fn key ->

     

       230
       230
       +
               key = to_string(key)

     

       231
       231
       +
               # TODO: what if it is nullable but not required?

     

       232
       232
       +
               key not in required && key not in nullable && key != "$type"

     

       233
       233
       +
             end)

     

       234
       234
       +
       

     

       235
       235
       +
           schema_module = Atex.NSID.to_atom(nsid)

     

       236
       236
       +
       

     

       237
       237
       +
           quoted_struct =

     

       238
       238
       +
             quote do

     

       239
       239
       +
               @enforce_keys unquote(enforced_keys)

     

       240
       240
       +
               defstruct unquote(struct_keys)

     

       241
       241
       +
       

     

       242
       242
       +
               def from_json(json) do

     

       243
       243
       +
                 case apply(unquote(schema_module), unquote(atomise(def_name)), [json]) do

     

       244
       244
       +
                   {:ok, map} -> {:ok, struct(__MODULE__, map)}

     

       245
       245
       +
                   err -> err

     

       246
       246
       +
                 end

     

       247
       247
       +
               end

     

       248
       248
       +
       

     

       249
       249
       +
               defimpl JSON.Encoder do

     

       250
       250
       +
                 @optional_if_nil_keys unquote(optional_if_nil_keys)

     

       251
       251
       +
       

     

       252
       252
       +
                 def encode(value, encoder) do

     

       253
       253
       +
                   value

     

       254
       254
       +
                   |> Map.from_struct()

     

       255
       255
       +
                   |> Enum.reject(fn {k, v} -> k in @optional_if_nil_keys && v == nil end)

     

       256
       256
       +
                   |> Enum.into(%{})

     

       257
       257
       +
                   |> Jason.Encoder.encode(encoder)

     

       258
       258
       +
                 end

     

       259
       259
       +
               end

     

       260
       260
       +
       

     

       261
       261
       +
               defimpl Jason.Encoder do

     

       262
       262
       +
                 @optional_if_nil_keys unquote(optional_if_nil_keys)

     

       263
       263
       +
       

     

       264
       264
       +
                 def encode(value, options) do

     

       265
       265
       +
                   value

     

       266
       266
       +
                   |> Map.from_struct()

     

       267
       267
       +
                   |> Enum.reject(fn {k, v} -> k in @optional_if_nil_keys && v == nil end)

     

       268
       268
       +
                   |> Enum.into(%{})

     

       269
       269
       +
                   |> Jason.Encode.map(options)

     

       270
       270
       +
                 end

     

       271
       271
       +
               end

     

       272
       272
       +
             end

     

       273
       273
       +
       

     

       274
       274
       +
           [{atomise(def_name), {:%{}, [], quoted_schemas}, {:%{}, [], quoted_types}, quoted_struct}]

     

       275
       275
       +
         end

     

       276
       276
       +
       

     

       277
       277
       +
         # TODO: validating errors?

     

       278
       278
       +
         defp def_to_schema(nsid, _def_name, %{type: "query"} = def) do

     

       279
       279
       +
           params =

     

       280
       280
       +
             if def[:parameters] do

     

       281
       281
       +
               [schema] =

     

       282
       282
       +
                 def_to_schema(nsid, "params", %{

     

       283
       283
       +
                   type: "object",

     

       284
       284
       +
                   required: Map.get(def.parameters, :required, []),

     

       285
       285
       +
                   properties: def.parameters.properties

     

       286
       286
       +
                 })

     

       287
       287
       +
       

     

       288
       288
       +
               schema

     

       289
       289
       +
             end

     

       290
       290
       +
       

     

       291
       291
       +
           output =

     

       292
       292
       +
             if def[:output] && def.output[:schema] do

     

       293
       293
       +
               [schema] = def_to_schema(nsid, "output", def.output.schema)

     

       294
       294
       +
               schema

     

       295
       295
       +
             end

     

       296
       296
       +
       

     

       297
       297
       +
           # Root struct containing `params`

     

       298
       298
       +
           main =

     

       299
       299
       +
             if params do

     

       300
       300
       +
               {

     

       301
       301
       +
                 :main,

     

       302
       302
       +
                 nil,

     

       303
       303
       +
                 quote do

     

       304
       304
       +
                   %__MODULE__{params: params()}

     

       305
       305
       +
                 end,

     

       306
       306
       +
                 quote do

     

       307
       307
       +
                   @enforce_keys [:params]

     

       308
       308
       +
                   defstruct params: nil

     

       309
       309
       +
                 end

     

       310
       310
       +
               }

     

       311
       311
       +
             else

     

       312
       312
       +
               {

     

       313
       313
       +
                 :main,

     

       314
       314
       +
                 nil,

     

       315
       315
       +
                 quote do

     

       316
       316
       +
                   %__MODULE__{}

     

       317
       317
       +
                 end,

     

       318
       318
       +
                 quote do

     

       319
       319
       +
                   defstruct []

     

       320
       320
       +
                 end

     

       321
       321
       +
               }

     

       322
       322
       +
             end

     

       323
       323
       +
       

     

       324
       324
       +
           [main, params, output]

     

       325
       325
       +
           |> Enum.reject(&is_nil/1)

     

       326
       326
       +
         end

     

       327
       327
       +
       

     

       328
       328
       +
         defp def_to_schema(nsid, _def_name, %{type: "procedure"} = def) do

     

       329
       329
       +
           # TODO: better keys for these

     

       330
       330
       +
           params =

     

       331
       331
       +
             if def[:parameters] do

     

       332
       332
       +
               [schema] =

     

       333
       333
       +
                 def_to_schema(nsid, "params", %{

     

       334
       334
       +
                   type: "object",

     

       335
       335
       +
                   required: Map.get(def.parameters, :required, []),

     

       336
       336
       +
                   properties: def.parameters.properties

     

       337
       337
       +
                 })

     

       338
       338
       +
       

     

       339
       339
       +
               schema

     

       340
       340
       +
             end

     

       341
       341
       +
       

     

       342
       342
       +
           output =

     

       343
       343
       +
             if def[:output] && def.output[:schema] do

     

       344
       344
       +
               [schema] = def_to_schema(nsid, "output", def.output.schema)

     

       345
       345
       +
               schema

     

       346
       346
       +
             end

     

       347
       347
       +
       

     

       348
       348
       +
           input =

     

       349
       349
       +
             if def[:input] && def.input[:schema] do

     

       350
       350
       +
               [schema] = def_to_schema(nsid, "input", def.input.schema)

     

       351
       351
       +
               schema

     

       352
       352
       +
             end

     

       353
       353
       +
       

     

       354
       354
       +
           # Root struct containing `input`, `raw_input`, and `params`

     

       355
       355
       +
           main =

     

       356
       356
       +
             {

     

       357
       357
       +
               :main,

     

       358
       358
       +
               nil,

     

       359
       359
       +
               cond do

     

       360
       360
       +
                 params && input ->

     

       361
       361
       +
                   quote do

     

       362
       362
       +
                     %__MODULE__{input: input(), params: params()}

     

       363
       363
       +
                   end

     

       364
       364
       +
       

     

       365
       365
       +
                 input ->

     

       366
       366
       +
                   quote do

     

       367
       367
       +
                     %__MODULE__{input: input()}

     

       368
       368
       +
                   end

     

       369
       369
       +
       

     

       370
       370
       +
                 params ->

     

       371
       371
       +
                   quote do

     

       372
       372
       +
                     %__MODULE__{raw_input: any(), params: params()}

     

       373
       373
       +
                   end

     

       374
       374
       +
       

     

       375
       375
       +
                 true ->

     

       376
       376
       +
                   quote do

     

       377
       377
       +
                     %__MODULE__{raw_input: any()}

     

       378
       378
       +
                   end

     

       379
       379
       +
               end,

     

       380
       380
       +
               cond do

     

       381
       381
       +
                 params && input ->

     

       382
       382
       +
                   quote do

     

       383
       383
       +
                     defstruct input: nil, params: nil

     

       384
       384
       +
                   end

     

       385
       385
       +
       

     

       386
       386
       +
                 input ->

     

       387
       387
       +
                   quote do

     

       388
       388
       +
                     defstruct input: nil

     

       389
       389
       +
                   end

     

       390
       390
       +
       

     

       391
       391
       +
                 params ->

     

       392
       392
       +
                   quote do

     

       393
       393
       +
                     defstruct raw_input: nil, params: nil

     

       394
       394
       +
                   end

     

       395
       395
       +
       

     

       396
       396
       +
                 true ->

     

       397
       397
       +
                   quote do

     

       398
       398
       +
                     defstruct raw_input: nil

     

       399
       399
       +
                   end

     

       400
       400
       +
               end

     

       401
       401
       +
             }

     

       402
       402
       +
       

     

       403
       403
       +
           [main, params, output, input]

     

       404
       404
       +
           |> Enum.reject(&is_nil/1)

     

       405
       405
       +
         end

     

       406
       406
       +
       

     

       407
       407
       +
         defp def_to_schema(nsid, _def_name, %{type: "subscription"} = def) do

     

       408
       408
       +
           params =

     

       409
       409
       +
             if def[:parameters] do

     

       410
       410
       +
               [schema] =

     

       411
       411
       +
                 def_to_schema(nsid, "params", %{

     

       412
       412
       +
                   type: "object",

     

       413
       413
       +
                   required: Map.get(def.parameters, :required, []),

     

       414
       414
       +
                   properties: def.parameters.properties

     

       415
       415
       +
                 })

     

       416
       416
       +
       

     

       417
       417
       +
               schema

     

       418
       418
       +
             end

     

       419
       419
       +
       

     

       420
       420
       +
           message =

     

       421
       421
       +
             if def[:message] do

     

       422
       422
       +
               [schema] = def_to_schema(nsid, "message", def.message.schema)

     

       423
       423
       +
               schema

     

       424
       424
       +
             end

     

       425
       425
       +
       

     

       426
       426
       +
           [params, message]

     

       427
       427
       +
           |> Enum.reject(&is_nil/1)

     

       428
       428
       +
         end

     

       429
       429
       +
       

     

       430
       430
       +
         defp def_to_schema(_nsid, def_name, %{type: "token"}) do

     

       431
       431
       +
           # TODO: make it a validator that expects the nsid + key.

     

       432
       432
       +
           [

     

       433
       433
       +
             {

     

       434
       434
       +
               atomise(def_name),

     

       435
       435
       +
               :string,

     

       436
       436
       +
               quote do

     

       437
       437
       +
                 String.t()

     

       438
       438
       +
               end

     

       439
       439
       +
             }

     

       440
       440
       +
           ]

     

       441
       441
       +
         end

     

       442
       442
       +
       

     

       443
       443
       +
         defp def_to_schema(nsid, def_name, %{type: type} = def)

     

       444
       444
       +
              when type in [

     

       445
       445
       +
                     "blob",

     

       446
       446
       +
                     "array",

     

       447
       447
       +
                     "boolean",

     

       448
       448
       +
                     "integer",

     

       449
       449
       +
                     "string",

     

       450
       450
       +
                     "bytes",

     

       451
       451
       +
                     "cid-link",

     

       452
       452
       +
                     "unknown",

     

       453
       453
       +
                     "ref",

     

       454
       454
       +
                     "union"

     

       455
       455
       +
                   ] do

     

       456
       456
       +
           {quoted_schema, quoted_type} = field_to_schema(def, nsid)

     

       457
       457
       +
           [{atomise(def_name), quoted_schema, quoted_type}]

     

       458
       458
       +
         end

     

       459
       459
       +
       

     

       460
       460
       +
         @spec field_to_schema(field_def :: %{type: String.t()}, nsid :: String.t()) ::

     

       461
       461
       +
                 {quoted_schema :: term(), quoted_typespec :: term()}

     

       462
       462
       +
         defp field_to_schema(%{type: "string"} = field, _nsid) do

     

       463
       463
       +
           fixed_schema = const_or_enum(field)

     

       464
       464
       +
       

     

       465
       465
       +
           if fixed_schema do

     

       466
       466
       +
             maybe_default(fixed_schema, field)

     

       467
       467
       +
           else

     

       468
       468
       +
             field

     

       469
       469
       +
             |> Map.take([

     

       470
       470
       +
               :format,

     

       471
       471
       +
               :maxLength,

     

       472
       472
       +
               :minLength,

     

       473
       473
       +
               :maxGraphemes,

     

       474
       474
       +
               :minGraphemes

     

       475
       475
       +
             ])

     

       476
       476
       +
             |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)

     

       477
       477
       +
             |> Validators.string()

     

       478
       478
       +
             |> maybe_default(field)

     

       479
       479
       +
           end

     

       480
       480
       +
           |> then(

     

       481
       481
       +
             &{Macro.escape(&1),

     

       482
       482
       +
              quote do

     

       483
       483
       +
                String.t()

     

       484
       484
       +
              end}

     

       485
       485
       +
           )

     

       486
       486
       +
         end

     

       487
       487
       +
       

     

       488
       488
       +
         defp field_to_schema(%{type: "boolean"} = field, _nsid) do

     

       489
       489
       +
           (const(field) || :boolean)

     

       490
       490
       +
           |> maybe_default(field)

     

       491
       491
       +
           |> then(

     

       492
       492
       +
             &{Macro.escape(&1),

     

       493
       493
       +
              quote do

     

       494
       494
       +
                boolean()

     

       495
       495
       +
              end}

     

       496
       496
       +
           )

     

       497
       497
       +
         end

     

       498
       498
       +
       

     

       499
       499
       +
         defp field_to_schema(%{type: "integer"} = field, _nsid) do

     

       500
       500
       +
           fixed_schema = const_or_enum(field)

     

       501
       501
       +
       

     

       502
       502
       +
           if fixed_schema do

     

       503
       503
       +
             maybe_default(fixed_schema, field)

     

       504
       504
       +
           else

     

       505
       505
       +
             field

     

       506
       506
       +
             |> Map.take([:maximum, :minimum])

     

       507
       507
       +
             |> Keyword.new()

     

       508
       508
       +
             |> Validators.integer()

     

       509
       509
       +
             |> maybe_default(field)

     

       510
       510
       +
           end

     

       511
       511
       +
           |> then(

     

       512
       512
       +
             &{

     

       513
       513
       +
               Macro.escape(&1),

     

       514
       514
       +
               # TODO: turn into range definition based on maximum/minimum

     

       515
       515
       +
               quote do

     

       516
       516
       +
                 integer()

     

       517
       517
       +
               end

     

       518
       518
       +
             }

     

       519
       519
       +
           )

     

       520
       520
       +
         end

     

       521
       521
       +
       

     

       522
       522
       +
         defp field_to_schema(%{type: "array", items: items} = field, nsid) do

     

       523
       523
       +
           {inner_schema, inner_type} = field_to_schema(items, nsid)

     

       524
       524
       +
       

     

       525
       525
       +
           field

     

       526
       526
       +
           |> Map.take([:maxLength, :minLength])

     

       527
       527
       +
           |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)

     

       528
       528
       +
           |> then(&Validators.array(inner_schema, &1))

     

       529
       529
       +
           |> then(&Macro.escape/1)

     

       530
       530
       +
           # TODO: we should be able to unquote this now...

     

       531
       531
       +
           # Can't unquote the inner_schema beforehand as that would risk evaluating `get_schema`s which don't exist yet.

     

       532
       532
       +
           # There's probably a better way to do this lol.

     

       533
       533
       +
           |> then(fn {:custom, {:{}, c, [Validators.Array, :validate, [quoted_inner_schema | args]]}} ->

     

       534
       534
       +
             {inner_schema, _} = Code.eval_quoted(quoted_inner_schema)

     

       535
       535
       +
             {:custom, {:{}, c, [Validators.Array, :validate, [inner_schema | args]]}}

     

       536
       536
       +
           end)

     

       537
       537
       +
           |> then(

     

       538
       538
       +
             &{&1,

     

       539
       539
       +
              quote do

     

       540
       540
       +
                list(unquote(inner_type))

     

       541
       541
       +
              end}

     

       542
       542
       +
           )

     

       543
       543
       +
         end

     

       544
       544
       +
       

     

       545
       545
       +
         defp field_to_schema(%{type: "blob"} = field, _nsid) do

     

       546
       546
       +
           field

     

       547
       547
       +
           |> Map.take([:accept, :maxSize])

     

       548
       548
       +
           |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)

     

       549
       549
       +
           |> Validators.blob()

     

       550
       550
       +
           |> then(

     

       551
       551
       +
             &{Macro.escape(&1),

     

       552
       552
       +
              quote do

     

       553
       553
       +
                Validators.blob()

     

       554
       554
       +
              end}

     

       555
       555
       +
           )

     

       556
       556
       +
         end

     

       557
       557
       +
       

     

       558
       558
       +
         defp field_to_schema(%{type: "bytes"} = field, _nsid) do

     

       559
       559
       +
           field

     

       560
       560
       +
           |> Map.take([:maxLength, :minLength])

     

       561
       561
       +
           |> Enum.map(fn {k, v} -> {Recase.to_snake(k), v} end)

     

       562
       562
       +
           |> Validators.bytes()

     

       563
       563
       +
           |> then(

     

       564
       564
       +
             &{Macro.escape(&1),

     

       565
       565
       +
              quote do

     

       566
       566
       +
                Validators.bytes()

     

       567
       567
       +
              end}

     

       568
       568
       +
           )

     

       569
       569
       +
         end

     

       570
       570
       +
       

     

       571
       571
       +
         defp field_to_schema(%{type: "cid-link"}, _nsid) do

     

       572
       572
       +
           Validators.cid_link()

     

       573
       573
       +
           |> then(

     

       574
       574
       +
             &{Macro.escape(&1),

     

       575
       575
       +
              quote do

     

       576
       576
       +
                Validators.cid_link()

     

       577
       577
       +
              end}

     

       578
       578
       +
           )

     

       579
       579
       +
         end

     

       580
       580
       +
       

     

       581
       581
       +
         # TODO: do i need to make sure these two deal with brands? Check objects in atp.tools

     

       582
       582
       +
         defp field_to_schema(%{type: "ref", ref: ref}, nsid) do

     

       583
       583
       +
           {nsid, fragment} =

     

       584
       584
       +
             nsid

     

       585
       585
       +
             |> Atex.NSID.expand_possible_fragment_shorthand(ref)

     

       586
       586
       +
             |> Atex.NSID.to_atom_with_fragment()

     

       587
       587
       +
       

     

       588
       588
       +
           fragment = Recase.to_snake(fragment)

     

       589
       589
       +
       

     

       590
       590
       +
           {

     

       591
       591
       +
             Macro.escape(Validators.lazy_ref(nsid, fragment)),

     

       592
       592
       +
             quote do

     

       593
       593
       +
               unquote(nsid).unquote(fragment)()

     

       594
       594
       +
             end

     

       595
       595
       +
           }

     

       596
       596
       +
         end

     

       597
       597
       +
       

     

       598
       598
       +
         defp field_to_schema(%{type: "union", refs: refs}, nsid) do

     

       599
       599
       +
           if refs == [] do

     

       600
       600
       +
             {quote do

     

       601
       601
       +
                {:oneof, []}

     

       602
       602
       +
              end, nil}

     

       603
       603
       +
           else

     

       604
       604
       +
             refs

     

       605
       605
       +
             |> Enum.map(fn ref ->

     

       606
       606
       +
               {nsid, fragment} =

     

       607
       607
       +
                 nsid

     

       608
       608
       +
                 |> Atex.NSID.expand_possible_fragment_shorthand(ref)

     

       609
       609
       +
                 |> Atex.NSID.to_atom_with_fragment()

     

       610
       610
       +
       

     

       611
       611
       +
               fragment = Recase.to_snake(fragment)

     

       612
       612
       +
       

     

       613
       613
       +
               {

     

       614
       614
       +
                 Macro.escape(Validators.lazy_ref(nsid, fragment)),

     

       615
       615
       +
                 quote do

     

       616
       616
       +
                   unquote(nsid).unquote(fragment)()

     

       617
       617
       +
                 end

     

       618
       618
       +
               }

     

       619
       619
       +
             end)

     

       620
       620
       +
             |> Enum.reduce({[], []}, fn {quoted_schema, quoted_type}, {schemas, types} ->

     

       621
       621
       +
               {[quoted_schema | schemas], [quoted_type | types]}

     

       622
       622
       +
             end)

     

       623
       623
       +
             |> then(fn {schemas, types} ->

     

       624
       624
       +
               {quote do

     

       625
       625
       +
                  {:oneof, unquote(schemas)}

     

       626
       626
       +
                end,

     

       627
       627
       +
                quote do

     

       628
       628
       +
                  unquote(join_with_pipe(types))

     

       629
       629
       +
                end}

     

       630
       630
       +
             end)

     

       631
       631
       +
           end

     

       632
       632
       +
         end

     

       633
       633
       +
       

     

       634
       634
       +
         # TODO: apparently should be a data object, not a primitive?

     

       635
       635
       +
         defp field_to_schema(%{type: "unknown"}, _nsid) do

     

       636
       636
       +
           {:any,

     

       637
       637
       +
            quote do

     

       638
       638
       +
              term()

     

       639
       639
       +
            end}

     

       640
       640
       +
         end

     

       641
       641
       +
       

     

       642
       642
       +
         defp field_to_schema(_field_def, _nsid), do: {nil, nil}

     

       643
       643
       +
       

     

       644
       644
       +
         defp maybe_default(schema, field) do

     

       645
       645
       +
           if field[:default] != nil,

     

       646
       646
       +
             do: {schema, {:default, field.default}},

     

       647
       647
       +
             else: schema

     

       648
       648
       +
         end

     

       649
       649
       +
       

     

       650
       650
       +
         defp const_or_enum(field), do: const(field) || enum(field)

     

       651
       651
       +
       

     

       652
       652
       +
         defp const(%{const: value}), do: {:literal, value}

     

       653
       653
       +
         defp const(_), do: nil

     

       654
       654
       +
       

     

       655
       655
       +
         defp enum(%{enum: values}), do: {:enum, values}

     

       656
       656
       +
         defp enum(_), do: nil

     

       657
       657
       +
       

     

       658
       658
       +
         defp atomise(x) when is_atom(x), do: x

     

       659
       659
       +
         defp atomise(x) when is_binary(x), do: String.to_atom(x)

     

       660
       660
       +
       

     

       661
       661
       +
         defp join_with_pipe(list) when is_list(list) do

     

       662
       662
       +
           [piped] = do_join_with_pipe(list)

     

       663
       663
       +
           piped

     

       664
       664
       +
         end

     

       665
       665
       +
       

     

       666
       666
       +
         defp do_join_with_pipe([head]), do: [head]

     

       667
       667
       +
         defp do_join_with_pipe([head | tail]), do: [{:|, [], [head | do_join_with_pipe(tail)]}]

     

       668
       668
       +
         defp do_join_with_pipe([]), do: []

     

       669
       669
       +
       end

+57

lib/atex/nsid.ex

···

       1
       1
       +
       defmodule Atex.NSID do

     

       2
       2
       +
         @re ~r/^[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)$/

     

       3
       3
       +
         # TODO: regex with support for fragment

     

       4
       4
       +
       

     

       5
       5
       +
         @spec re() :: Regex.t()

     

       6
       6
       +
         def re, do: @re

     

       7
       7
       +
       

     

       8
       8
       +
         @spec match?(String.t()) :: boolean()

     

       9
       9
       +
         def match?(value), do: Regex.match?(@re, value)

     

       10
       10
       +
       

     

       11
       11
       +
         # TODO: methods for fetching the authority and name from a nsid.

     

       12
       12
       +
         # maybe stuff for fetching the repo that belongs to an authority

     

       13
       13
       +
       

     

       14
       14
       +
         @spec to_atom(String.t()) :: atom()

     

       15
       15
       +
         def to_atom(nsid, fully_qualify \\ true) do

     

       16
       16
       +
           nsid

     

       17
       17
       +
           |> String.split(".")

     

       18
       18
       +
           |> Enum.map(&Recase.to_pascal/1)

     

       19
       19
       +
           |> then(fn parts ->

     

       20
       20
       +
             if fully_qualify do

     

       21
       21
       +
               ["Elixir" | parts]

     

       22
       22
       +
             else

     

       23
       23
       +
               parts

     

       24
       24
       +
             end

     

       25
       25
       +
           end)

     

       26
       26
       +
           |> Enum.join(".")

     

       27
       27
       +
           |> String.to_atom()

     

       28
       28
       +
         end

     

       29
       29
       +
       

     

       30
       30
       +
         @spec to_atom_with_fragment(String.t()) :: {atom(), atom()}

     

       31
       31
       +
         def to_atom_with_fragment(nsid) do

     

       32
       32
       +
           if !String.contains?(nsid, "#") do

     

       33
       33
       +
             {to_atom(nsid), :main}

     

       34
       34
       +
           else

     

       35
       35
       +
             [nsid, fragment] = String.split(nsid, "#")

     

       36
       36
       +
             {to_atom(nsid), String.to_atom(fragment)}

     

       37
       37
       +
           end

     

       38
       38
       +
         end

     

       39
       39
       +
       

     

       40
       40
       +
         @spec expand_possible_fragment_shorthand(String.t(), String.t()) :: String.t()

     

       41
       41
       +
         def expand_possible_fragment_shorthand(main_nsid, possible_fragment) do

     

       42
       42
       +
           if String.starts_with?(possible_fragment, "#") do

     

       43
       43
       +
             main_nsid <> possible_fragment

     

       44
       44
       +
           else

     

       45
       45
       +
             possible_fragment

     

       46
       46
       +
           end

     

       47
       47
       +
         end

     

       48
       48
       +
       

     

       49
       49
       +
         @spec canonical_name(String.t(), String.t()) :: String.t()

     

       50
       50
       +
         def canonical_name(nsid, fragment) do

     

       51
       51
       +
           if fragment == "main" do

     

       52
       52
       +
             nsid

     

       53
       53
       +
           else

     

       54
       54
       +
             "#{nsid}##{fragment}"

     

       55
       55
       +
           end

     

       56
       56
       +
         end

     

       57
       57
       +
       end

+165

lib/atex/oauth/plug.ex

···

       1
       1
       +
       defmodule Atex.OAuth.Plug do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Plug router for handling AT Protocol's OAuth flow.

     

       4
       4
       +
       

     

       5
       5
       +
         This module provides three endpoints:

     

       6
       6
       +
       

     

       7
       7
       +
         - `GET /login?handle=<handle>` - Initiates the OAuth authorization flow for

     

       8
       8
       +
           a given handle

     

       9
       9
       +
         - `GET /callback` - Handles the OAuth callback after user authorization

     

       10
       10
       +
         - `GET /client-metadata.json` - Serves the OAuth client metadata

     

       11
       11
       +
       

     

       12
       12
       +
         ## Usage

     

       13
       13
       +
       

     

       14
       14
       +
         This module requires `Plug.Session` to be in your pipeline, as well as

     

       15
       15
       +
         `secret_key_base` to have been set on your connections. Ideally it should be

     

       16
       16
       +
         routed to via `Plug.Router.forward/2`, under a route like "/oauth".

     

       17
       17
       +
       

     

       18
       18
       +
         ## Example

     

       19
       19
       +
       

     

       20
       20
       +
         Example implementation showing how to set up the OAuth plug with proper

     

       21
       21
       +
         session handling:

     

       22
       22
       +
       

     

       23
       23
       +
             defmodule ExampleOAuthPlug do

     

       24
       24
       +
               use Plug.Router

     

       25
       25
       +
       

     

       26
       26
       +
               plug :put_secret_key_base

     

       27
       27
       +
       

     

       28
       28
       +
               plug Plug.Session,

     

       29
       29
       +
                 store: :cookie,

     

       30
       30
       +
                 key: "atex-oauth",

     

       31
       31
       +
                 signing_salt: "signing-salt"

     

       32
       32
       +
       

     

       33
       33
       +
               plug :match

     

       34
       34
       +
               plug :dispatch

     

       35
       35
       +
       

     

       36
       36
       +
               forward "/oauth", to: Atex.OAuth.Plug

     

       37
       37
       +
       

     

       38
       38
       +
               def put_secret_key_base(conn, _) do

     

       39
       39
       +
                 put_in(

     

       40
       40
       +
                   conn.secret_key_base,

     

       41
       41
       +
                   "very long key base with at least 64 bytes"

     

       42
       42
       +
                 )

     

       43
       43
       +
               end

     

       44
       44
       +
             end

     

       45
       45
       +
       

     

       46
       46
       +
         ## Session Storage

     

       47
       47
       +
       

     

       48
       48
       +
         After successful authentication, the plug stores these in the session:

     

       49
       49
       +
       

     

       50
       50
       +
         - `:tokens` - The access token response containing access_token,

     

       51
       51
       +
           refresh_token, did, and expires_at

     

       52
       52
       +
         - `:dpop_nonce` -

     

       53
       53
       +
         - `:dpop_key` - The DPoP JWK for generating DPoP proofs

     

       54
       54
       +
         """

     

       55
       55
       +
         require Logger

     

       56
       56
       +
         use Plug.Router

     

       57
       57
       +
         require Plug.Router

     

       58
       58
       +
         alias Atex.OAuth

     

       59
       59
       +
         alias Atex.{IdentityResolver, IdentityResolver.DIDDocument}

     

       60
       60
       +
       

     

       61
       61
       +
         @oauth_cookie_opts [path: "/", http_only: true, secure: true, same_site: "lax", max_age: 600]

     

       62
       62
       +
       

     

       63
       63
       +
         plug :match

     

       64
       64
       +
         plug :dispatch

     

       65
       65
       +
       

     

       66
       66
       +
         get "/login" do

     

       67
       67
       +
           conn = fetch_query_params(conn)

     

       68
       68
       +
           handle = conn.query_params["handle"]

     

       69
       69
       +
       

     

       70
       70
       +
           if !handle do

     

       71
       71
       +
             send_resp(conn, 400, "Need `handle` query parameter")

     

       72
       72
       +
           else

     

       73
       73
       +
             case IdentityResolver.resolve(handle) do

     

       74
       74
       +
               {:ok, identity} ->

     

       75
       75
       +
                 pds = DIDDocument.get_pds_endpoint(identity.document)

     

       76
       76
       +
                 {:ok, authz_server} = OAuth.get_authorization_server(pds)

     

       77
       77
       +
                 {:ok, authz_metadata} = OAuth.get_authorization_server_metadata(authz_server)

     

       78
       78
       +
                 state = OAuth.create_nonce()

     

       79
       79
       +
                 code_verifier = OAuth.create_nonce()

     

       80
       80
       +
       

     

       81
       81
       +
                 case OAuth.create_authorization_url(

     

       82
       82
       +
                        authz_metadata,

     

       83
       83
       +
                        state,

     

       84
       84
       +
                        code_verifier,

     

       85
       85
       +
                        handle

     

       86
       86
       +
                      ) do

     

       87
       87
       +
                   {:ok, authz_url} ->

     

       88
       88
       +
                     conn

     

       89
       89
       +
                     |> put_resp_cookie("state", state, @oauth_cookie_opts)

     

       90
       90
       +
                     |> put_resp_cookie("code_verifier", code_verifier, @oauth_cookie_opts)

     

       91
       91
       +
                     |> put_resp_cookie("issuer", authz_metadata.issuer, @oauth_cookie_opts)

     

       92
       92
       +
                     |> put_resp_header("location", authz_url)

     

       93
       93
       +
                     |> send_resp(307, "")

     

       94
       94
       +
       

     

       95
       95
       +
                   err ->

     

       96
       96
       +
                     Logger.error("failed to reate authorization url, #{inspect(err)}")

     

       97
       97
       +
                     send_resp(conn, 500, "Internal server error")

     

       98
       98
       +
                 end

     

       99
       99
       +
       

     

       100
       100
       +
               {:error, err} ->

     

       101
       101
       +
                 Logger.error("Failed to resolve handle, #{inspect(err)}")

     

       102
       102
       +
                 send_resp(conn, 400, "Invalid handle")

     

       103
       103
       +
             end

     

       104
       104
       +
           end

     

       105
       105
       +
         end

     

       106
       106
       +
       

     

       107
       107
       +
         get "/client-metadata.json" do

     

       108
       108
       +
           conn

     

       109
       109
       +
           |> put_resp_content_type("application/json")

     

       110
       110
       +
           |> send_resp(200, JSON.encode_to_iodata!(OAuth.create_client_metadata()))

     

       111
       111
       +
         end

     

       112
       112
       +
       

     

       113
       113
       +
         get "/callback" do

     

       114
       114
       +
           conn = conn |> fetch_query_params() |> fetch_session()

     

       115
       115
       +
           cookies = get_cookies(conn)

     

       116
       116
       +
           stored_state = cookies["state"]

     

       117
       117
       +
           stored_code_verifier = cookies["code_verifier"]

     

       118
       118
       +
           stored_issuer = cookies["issuer"]

     

       119
       119
       +
       

     

       120
       120
       +
           code = conn.query_params["code"]

     

       121
       121
       +
           state = conn.query_params["state"]

     

       122
       122
       +
       

     

       123
       123
       +
           if !stored_state || !stored_code_verifier || !stored_issuer || (!code || !state) ||

     

       124
       124
       +
                stored_state != state do

     

       125
       125
       +
             send_resp(conn, 400, "Invalid request")

     

       126
       126
       +
           else

     

       127
       127
       +
             with {:ok, authz_metadata} <- OAuth.get_authorization_server_metadata(stored_issuer),

     

       128
       128
       +
                  dpop_key <- JOSE.JWK.generate_key({:ec, "P-256"}),

     

       129
       129
       +
                  {:ok, tokens, nonce} <-

     

       130
       130
       +
                    OAuth.validate_authorization_code(

     

       131
       131
       +
                      authz_metadata,

     

       132
       132
       +
                      dpop_key,

     

       133
       133
       +
                      code,

     

       134
       134
       +
                      stored_code_verifier

     

       135
       135
       +
                    ),

     

       136
       136
       +
                  {:ok, identity} <- IdentityResolver.resolve(tokens.did),

     

       137
       137
       +
                  # Make sure pds' issuer matches the stored one (just in case)

     

       138
       138
       +
                  pds <- DIDDocument.get_pds_endpoint(identity.document),

     

       139
       139
       +
                  {:ok, authz_server} <- OAuth.get_authorization_server(pds),

     

       140
       140
       +
                  true <- authz_server == stored_issuer do

     

       141
       141
       +
               conn

     

       142
       142
       +
               |> delete_resp_cookie("state", @oauth_cookie_opts)

     

       143
       143
       +
               |> delete_resp_cookie("code_verifier", @oauth_cookie_opts)

     

       144
       144
       +
               |> delete_resp_cookie("issuer", @oauth_cookie_opts)

     

       145
       145
       +
               |> put_session(:atex_oauth, %{

     

       146
       146
       +
                 access_token: tokens.access_token,

     

       147
       147
       +
                 refresh_token: tokens.refresh_token,

     

       148
       148
       +
                 did: tokens.did,

     

       149
       149
       +
                 pds: pds,

     

       150
       150
       +
                 expires_at: tokens.expires_at,

     

       151
       151
       +
                 dpop_nonce: nonce,

     

       152
       152
       +
                 dpop_key: dpop_key

     

       153
       153
       +
               })

     

       154
       154
       +
               |> send_resp(200, "success!! hello #{tokens.did}")

     

       155
       155
       +
             else

     

       156
       156
       +
               false ->

     

       157
       157
       +
                 send_resp(conn, 400, "OAuth issuer does not match your PDS' authorization server")

     

       158
       158
       +
       

     

       159
       159
       +
               err ->

     

       160
       160
       +
                 Logger.error("failed to validate oauth callback: #{inspect(err)}")

     

       161
       161
       +
                 send_resp(conn, 500, "Internal server error")

     

       162
       162
       +
             end

     

       163
       163
       +
           end

     

       164
       164
       +
         end

     

       165
       165
       +
       end

+531

lib/atex/oauth.ex

···

       1
       1
       +
       defmodule Atex.OAuth do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         OAuth 2.0 implementation for AT Protocol authentication.

     

       4
       4
       +
       

     

       5
       5
       +
         This module provides utilities for implementing OAuth flows compliant with the

     

       6
       6
       +
         AT Protocol specification. It includes support for:

     

       7
       7
       +
       

     

       8
       8
       +
         - Pushed Authorization Requests (PAR)

     

       9
       9
       +
         - DPoP (Demonstration of Proof of Possession) tokens

     

       10
       10
       +
         - JWT client assertions

     

       11
       11
       +
         - PKCE (Proof Key for Code Exchange)

     

       12
       12
       +
         - Token refresh

     

       13
       13
       +
         - Handle to PDS resolution

     

       14
       14
       +
       

     

       15
       15
       +
         ## Configuration

     

       16
       16
       +
       

     

       17
       17
       +
         See `Atex.Config.OAuth` module for configuration documentation.

     

       18
       18
       +
       

     

       19
       19
       +
         ## Usage Example

     

       20
       20
       +
       

     

       21
       21
       +
             iex> pds = "https://bsky.social"

     

       22
       22
       +
             iex> login_hint = "example.com"

     

       23
       23
       +
             iex> {:ok, authz_server} = Atex.OAuth.get_authorization_server(pds)

     

       24
       24
       +
             iex> {:ok, authz_metadata} = Atex.OAuth.get_authorization_server_metadata(authz_server)

     

       25
       25
       +
             iex> state = Atex.OAuth.create_nonce()

     

       26
       26
       +
             iex> code_verifier = Atex.OAuth.create_nonce()

     

       27
       27
       +
             iex> {:ok, auth_url} = Atex.OAuth.create_authorization_url(

     

       28
       28
       +
               authz_metadata,

     

       29
       29
       +
               state,

     

       30
       30
       +
               code_verifier,

     

       31
       31
       +
               login_hint

     

       32
       32
       +
             )

     

       33
       33
       +
         """

     

       34
       34
       +
       

     

       35
       35
       +
         @type authorization_metadata() :: %{

     

       36
       36
       +
                 issuer: String.t(),

     

       37
       37
       +
                 par_endpoint: String.t(),

     

       38
       38
       +
                 token_endpoint: String.t(),

     

       39
       39
       +
                 authorization_endpoint: String.t()

     

       40
       40
       +
               }

     

       41
       41
       +
       

     

       42
       42
       +
         @type tokens() :: %{

     

       43
       43
       +
                 access_token: String.t(),

     

       44
       44
       +
                 refresh_token: String.t(),

     

       45
       45
       +
                 did: String.t(),

     

       46
       46
       +
                 expires_at: NaiveDateTime.t()

     

       47
       47
       +
               }

     

       48
       48
       +
       

     

       49
       49
       +
         alias Atex.Config.OAuth, as: Config

     

       50
       50
       +
       

     

       51
       51
       +
         @doc """

     

       52
       52
       +
         Get a map cnotaining the client metadata information needed for an

     

       53
       53
       +
         authorization server to validate this client.

     

       54
       54
       +
         """

     

       55
       55
       +
         @spec create_client_metadata() :: map()

     

       56
       56
       +
         def create_client_metadata() do

     

       57
       57
       +
           key = Config.get_key()

     

       58
       58
       +
           {_, jwk} = key |> JOSE.JWK.to_public_map()

     

       59
       59
       +
           jwk = Map.merge(jwk, %{use: "sig", kid: key.fields["kid"]})

     

       60
       60
       +
       

     

       61
       61
       +
           %{

     

       62
       62
       +
             client_id: Config.client_id(),

     

       63
       63
       +
             redirect_uris: [Config.redirect_uri() | Config.extra_redirect_uris()],

     

       64
       64
       +
             application_type: "web",

     

       65
       65
       +
             grant_types: ["authorization_code", "refresh_token"],

     

       66
       66
       +
             scope: Config.scopes(),

     

       67
       67
       +
             response_type: ["code"],

     

       68
       68
       +
             token_endpoint_auth_method: "private_key_jwt",

     

       69
       69
       +
             token_endpoint_auth_signing_alg: "ES256",

     

       70
       70
       +
             dpop_bound_access_tokens: true,

     

       71
       71
       +
             jwks: %{keys: [jwk]}

     

       72
       72
       +
           }

     

       73
       73
       +
         end

     

       74
       74
       +
       

     

       75
       75
       +
         @doc """

     

       76
       76
       +
         Retrieves the configured JWT private key for signing client assertions.

     

       77
       77
       +
       

     

       78
       78
       +
         Loads the private key from configuration, decodes the base64-encoded DER data,

     

       79
       79
       +
         and creates a JOSE JWK structure with the key ID field set.

     

       80
       80
       +
       

     

       81
       81
       +
         ## Returns

     

       82
       82
       +
       

     

       83
       83
       +
         A `JOSE.JWK` struct containing the private key and key identifier.

     

       84
       84
       +
       

     

       85
       85
       +
         ## Raises

     

       86
       86
       +
       

     

       87
       87
       +
         * `Application.Env.Error` if the private_key or key_id configuration is missing

     

       88
       88
       +
       

     

       89
       89
       +
         ## Examples

     

       90
       90
       +
       

     

       91
       91
       +
             key = OAuth.get_key()

     

       92
       92
       +
             key = OAuth.get_key()

     

       93
       93
       +
         """

     

       94
       94
       +
         @spec get_key() :: JOSE.JWK.t()

     

       95
       95
       +
         def get_key(), do: Config.get_key()

     

       96
       96
       +
       

     

       97
       97
       +
         @doc false

     

       98
       98
       +
         @spec random_b64(integer()) :: String.t()

     

       99
       99
       +
         def random_b64(length) do

     

       100
       100
       +
           :crypto.strong_rand_bytes(length)

     

       101
       101
       +
           |> Base.url_encode64(padding: false)

     

       102
       102
       +
         end

     

       103
       103
       +
       

     

       104
       104
       +
         @doc false

     

       105
       105
       +
         @spec create_nonce() :: String.t()

     

       106
       106
       +
         def create_nonce(), do: random_b64(32)

     

       107
       107
       +
       

     

       108
       108
       +
         @doc """

     

       109
       109
       +
         Create an OAuth authorization URL for a PDS.

     

       110
       110
       +
       

     

       111
       111
       +
         Submits a PAR request to the authorization server and constructs the

     

       112
       112
       +
         authorization URL with the returned request URI. Supports PKCE, DPoP, and

     

       113
       113
       +
         client assertions as required by the AT Protocol.

     

       114
       114
       +
       

     

       115
       115
       +
         ## Parameters

     

       116
       116
       +
       

     

       117
       117
       +
           - `authz_metadata` - Authorization server metadata containing endpoints, fetched from `get_authorization_server_metadata/1`

     

       118
       118
       +
           - `state` - Random token for session validation

     

       119
       119
       +
           - `code_verifier` - PKCE code verifier

     

       120
       120
       +
           - `login_hint` - User identifier (handle or DID) for pre-filled login

     

       121
       121
       +
       

     

       122
       122
       +
         ## Returns

     

       123
       123
       +
       

     

       124
       124
       +
           - `{:ok, authorization_url}` - Successfully created authorization URL

     

       125
       125
       +
           - `{:ok, :invalid_par_response}` - Server respondend incorrectly to the request

     

       126
       126
       +
           - `{:error, reason}` - Error creating authorization URL

     

       127
       127
       +
         """

     

       128
       128
       +
         @spec create_authorization_url(

     

       129
       129
       +
                 authorization_metadata(),

     

       130
       130
       +
                 String.t(),

     

       131
       131
       +
                 String.t(),

     

       132
       132
       +
                 String.t()

     

       133
       133
       +
               ) :: {:ok, String.t()} | {:error, any()}

     

       134
       134
       +
         def create_authorization_url(

     

       135
       135
       +
               authz_metadata,

     

       136
       136
       +
               state,

     

       137
       137
       +
               code_verifier,

     

       138
       138
       +
               login_hint

     

       139
       139
       +
             ) do

     

       140
       140
       +
           code_challenge = :crypto.hash(:sha256, code_verifier) |> Base.url_encode64(padding: false)

     

       141
       141
       +
           key = get_key()

     

       142
       142
       +
       

     

       143
       143
       +
           client_assertion =

     

       144
       144
       +
             create_client_assertion(key, Config.client_id(), authz_metadata.issuer)

     

       145
       145
       +
       

     

       146
       146
       +
           body =

     

       147
       147
       +
             %{

     

       148
       148
       +
               response_type: "code",

     

       149
       149
       +
               client_id: Config.client_id(),

     

       150
       150
       +
               redirect_uri: Config.redirect_uri(),

     

       151
       151
       +
               state: state,

     

       152
       152
       +
               code_challenge_method: "S256",

     

       153
       153
       +
               code_challenge: code_challenge,

     

       154
       154
       +
               scope: Config.scopes(),

     

       155
       155
       +
               client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",

     

       156
       156
       +
               client_assertion: client_assertion,

     

       157
       157
       +
               login_hint: login_hint

     

       158
       158
       +
             }

     

       159
       159
       +
       

     

       160
       160
       +
           case Req.post(authz_metadata.par_endpoint, form: body) do

     

       161
       161
       +
             {:ok, %{body: %{"request_uri" => request_uri}}} ->

     

       162
       162
       +
               query =

     

       163
       163
       +
                 %{client_id: Config.client_id(), request_uri: request_uri}

     

       164
       164
       +
                 |> URI.encode_query()

     

       165
       165
       +
       

     

       166
       166
       +
               {:ok, "#{authz_metadata.authorization_endpoint}?#{query}"}

     

       167
       167
       +
       

     

       168
       168
       +
             {:ok, _} ->

     

       169
       169
       +
               {:error, :invalid_par_response}

     

       170
       170
       +
       

     

       171
       171
       +
             err ->

     

       172
       172
       +
               err

     

       173
       173
       +
           end

     

       174
       174
       +
         end

     

       175
       175
       +
       

     

       176
       176
       +
         @doc """

     

       177
       177
       +
         Exchange an OAuth authorization code for a set of access and refresh tokens.

     

       178
       178
       +
       

     

       179
       179
       +
         Validates the authorization code by submitting it to the token endpoint along with

     

       180
       180
       +
         the PKCE code verifier and client assertion. Returns access tokens for making authenticated

     

       181
       181
       +
         requests to the relevant user's PDS.

     

       182
       182
       +
       

     

       183
       183
       +
         ## Parameters

     

       184
       184
       +
       

     

       185
       185
       +
           - `authz_metadata` - Authorization server metadata containing token endpoint

     

       186
       186
       +
           - `dpop_key` - JWK for DPoP token generation

     

       187
       187
       +
           - `code` - Authorization code from OAuth callback

     

       188
       188
       +
           - `code_verifier` - PKCE code verifier from authorization flow

     

       189
       189
       +
       

     

       190
       190
       +
         ## Returns

     

       191
       191
       +
       

     

       192
       192
       +
           - `{:ok, tokens, nonce}` - Successfully obtained tokens with returned DPoP nonce

     

       193
       193
       +
           - `{:error, reason}` - Error exchanging code for tokens

     

       194
       194
       +
         """

     

       195
       195
       +
         @spec validate_authorization_code(

     

       196
       196
       +
                 authorization_metadata(),

     

       197
       197
       +
                 JOSE.JWK.t(),

     

       198
       198
       +
                 String.t(),

     

       199
       199
       +
                 String.t()

     

       200
       200
       +
               ) :: {:ok, tokens(), String.t()} | {:error, any()}

     

       201
       201
       +
         def validate_authorization_code(

     

       202
       202
       +
               authz_metadata,

     

       203
       203
       +
               dpop_key,

     

       204
       204
       +
               code,

     

       205
       205
       +
               code_verifier

     

       206
       206
       +
             ) do

     

       207
       207
       +
           key = get_key()

     

       208
       208
       +
       

     

       209
       209
       +
           client_assertion =

     

       210
       210
       +
             create_client_assertion(key, Config.client_id(), authz_metadata.issuer)

     

       211
       211
       +
       

     

       212
       212
       +
           body =

     

       213
       213
       +
             %{

     

       214
       214
       +
               grant_type: "authorization_code",

     

       215
       215
       +
               client_id: Config.client_id(),

     

       216
       216
       +
               redirect_uri: Config.redirect_uri(),

     

       217
       217
       +
               code: code,

     

       218
       218
       +
               code_verifier: code_verifier,

     

       219
       219
       +
               client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",

     

       220
       220
       +
               client_assertion: client_assertion

     

       221
       221
       +
             }

     

       222
       222
       +
       

     

       223
       223
       +
           Req.new(method: :post, url: authz_metadata.token_endpoint, form: body)

     

       224
       224
       +
           |> send_oauth_dpop_request(dpop_key)

     

       225
       225
       +
           |> case do

     

       226
       226
       +
             {:ok,

     

       227
       227
       +
              %{

     

       228
       228
       +
                "access_token" => access_token,

     

       229
       229
       +
                "refresh_token" => refresh_token,

     

       230
       230
       +
                "expires_in" => expires_in,

     

       231
       231
       +
                "sub" => did

     

       232
       232
       +
              }, nonce} ->

     

       233
       233
       +
               expires_at = NaiveDateTime.utc_now() |> NaiveDateTime.add(expires_in, :second)

     

       234
       234
       +
       

     

       235
       235
       +
               {:ok,

     

       236
       236
       +
                %{

     

       237
       237
       +
                  access_token: access_token,

     

       238
       238
       +
                  refresh_token: refresh_token,

     

       239
       239
       +
                  did: did,

     

       240
       240
       +
                  expires_at: expires_at

     

       241
       241
       +
                }, nonce}

     

       242
       242
       +
       

     

       243
       243
       +
             err ->

     

       244
       244
       +
               err

     

       245
       245
       +
           end

     

       246
       246
       +
         end

     

       247
       247
       +
       

     

       248
       248
       +
         def refresh_token(refresh_token, dpop_key, issuer, token_endpoint) do

     

       249
       249
       +
           key = get_key()

     

       250
       250
       +
       

     

       251
       251
       +
           client_assertion =

     

       252
       252
       +
             create_client_assertion(key, Config.client_id(), issuer)

     

       253
       253
       +
       

     

       254
       254
       +
           body = %{

     

       255
       255
       +
             grant_type: "refresh_token",

     

       256
       256
       +
             refresh_token: refresh_token,

     

       257
       257
       +
             client_id: Config.client_id(),

     

       258
       258
       +
             client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",

     

       259
       259
       +
             client_assertion: client_assertion

     

       260
       260
       +
           }

     

       261
       261
       +
       

     

       262
       262
       +
           Req.new(method: :post, url: token_endpoint, form: body)

     

       263
       263
       +
           |> send_oauth_dpop_request(dpop_key)

     

       264
       264
       +
           |> case do

     

       265
       265
       +
             {:ok,

     

       266
       266
       +
              %{

     

       267
       267
       +
                "access_token" => access_token,

     

       268
       268
       +
                "refresh_token" => refresh_token,

     

       269
       269
       +
                "expires_in" => expires_in,

     

       270
       270
       +
                "sub" => did

     

       271
       271
       +
              }, nonce} ->

     

       272
       272
       +
               expires_at = NaiveDateTime.utc_now() |> NaiveDateTime.add(expires_in, :second)

     

       273
       273
       +
       

     

       274
       274
       +
               {:ok,

     

       275
       275
       +
                %{

     

       276
       276
       +
                  access_token: access_token,

     

       277
       277
       +
                  refresh_token: refresh_token,

     

       278
       278
       +
                  did: did,

     

       279
       279
       +
                  expires_at: expires_at

     

       280
       280
       +
                }, nonce}

     

       281
       281
       +
       

     

       282
       282
       +
             err ->

     

       283
       283
       +
               err

     

       284
       284
       +
           end

     

       285
       285
       +
         end

     

       286
       286
       +
       

     

       287
       287
       +
         @doc """

     

       288
       288
       +
         Fetch the authorization server for a given Personal Data Server (PDS).

     

       289
       289
       +
       

     

       290
       290
       +
         Makes a request to the PDS's `.well-known/oauth-protected-resource` endpoint

     

       291
       291
       +
         to discover the associated authorization server that should be used for the

     

       292
       292
       +
         OAuth flow.

     

       293
       293
       +
       

     

       294
       294
       +
         ## Parameters

     

       295
       295
       +
       

     

       296
       296
       +
           - `pds_host` - Base URL of the PDS (e.g., "https://bsky.social")

     

       297
       297
       +
       

     

       298
       298
       +
         ## Returns

     

       299
       299
       +
       

     

       300
       300
       +
           - `{:ok, authorization_server}` - Successfully discovered authorization

     

       301
       301
       +
             server URL

     

       302
       302
       +
           - `{:error, :invalid_metadata}` - Server returned invalid metadata

     

       303
       303
       +
           - `{:error, reason}` - Error discovering authorization server

     

       304
       304
       +
         """

     

       305
       305
       +
         @spec get_authorization_server(String.t()) :: {:ok, String.t()} | {:error, any()}

     

       306
       306
       +
         def get_authorization_server(pds_host) do

     

       307
       307
       +
           "#{pds_host}/.well-known/oauth-protected-resource"

     

       308
       308
       +
           |> Req.get()

     

       309
       309
       +
           |> case do

     

       310
       310
       +
             # TODO: what to do when multiple authorization servers?

     

       311
       311
       +
             {:ok, %{body: %{"authorization_servers" => [authz_server | _]}}} -> {:ok, authz_server}

     

       312
       312
       +
             {:ok, _} -> {:error, :invalid_metadata}

     

       313
       313
       +
             err -> err

     

       314
       314
       +
           end

     

       315
       315
       +
         end

     

       316
       316
       +
       

     

       317
       317
       +
         @doc """

     

       318
       318
       +
         Fetch the metadata for an OAuth authorization server.

     

       319
       319
       +
       

     

       320
       320
       +
         Retrieves the metadata from the authorization server's

     

       321
       321
       +
         `.well-known/oauth-authorization-server` endpoint, providing endpoint URLs

     

       322
       322
       +
         required for the OAuth flow.

     

       323
       323
       +
       

     

       324
       324
       +
         ## Parameters

     

       325
       325
       +
       

     

       326
       326
       +
           - `issuer` - Authorization server issuer URL

     

       327
       327
       +
       

     

       328
       328
       +
         ## Returns

     

       329
       329
       +
       

     

       330
       330
       +
           - `{:ok, metadata}` - Successfully retrieved authorization server metadata

     

       331
       331
       +
           - `{:error, :invalid_metadata}` - Server returned invalid metadata

     

       332
       332
       +
           - `{:error, :invalid_issuer}` - Issuer mismatch in metadata

     

       333
       333
       +
           - `{:error, any()}` - Other error fetching metadata

     

       334
       334
       +
         """

     

       335
       335
       +
         @spec get_authorization_server_metadata(String.t()) ::

     

       336
       336
       +
                 {:ok, authorization_metadata()} | {:error, any()}

     

       337
       337
       +
         def get_authorization_server_metadata(issuer) do

     

       338
       338
       +
           "#{issuer}/.well-known/oauth-authorization-server"

     

       339
       339
       +
           |> Req.get()

     

       340
       340
       +
           |> case do

     

       341
       341
       +
             {:ok,

     

       342
       342
       +
              %{

     

       343
       343
       +
                body: %{

     

       344
       344
       +
                  "issuer" => metadata_issuer,

     

       345
       345
       +
                  "pushed_authorization_request_endpoint" => par_endpoint,

     

       346
       346
       +
                  "token_endpoint" => token_endpoint,

     

       347
       347
       +
                  "authorization_endpoint" => authorization_endpoint

     

       348
       348
       +
                }

     

       349
       349
       +
              }} ->

     

       350
       350
       +
               if issuer != metadata_issuer do

     

       351
       351
       +
                 {:error, :invaild_issuer}

     

       352
       352
       +
               else

     

       353
       353
       +
                 {:ok,

     

       354
       354
       +
                  %{

     

       355
       355
       +
                    issuer: metadata_issuer,

     

       356
       356
       +
                    par_endpoint: par_endpoint,

     

       357
       357
       +
                    token_endpoint: token_endpoint,

     

       358
       358
       +
                    authorization_endpoint: authorization_endpoint

     

       359
       359
       +
                  }}

     

       360
       360
       +
               end

     

       361
       361
       +
       

     

       362
       362
       +
             {:ok, _} ->

     

       363
       363
       +
               {:error, :invalid_metadata}

     

       364
       364
       +
       

     

       365
       365
       +
             err ->

     

       366
       366
       +
               err

     

       367
       367
       +
           end

     

       368
       368
       +
         end

     

       369
       369
       +
       

     

       370
       370
       +
         @spec send_oauth_dpop_request(Req.Request.t(), JOSE.JWK.t(), String.t() | nil) ::

     

       371
       371
       +
                 {:ok, map(), String.t()} | {:error, any(), String.t()}

     

       372
       372
       +
         def send_oauth_dpop_request(request, dpop_key, nonce \\ nil) do

     

       373
       373
       +
           dpop_token = create_dpop_token(dpop_key, request, nonce)

     

       374
       374
       +
       

     

       375
       375
       +
           request

     

       376
       376
       +
           |> Req.Request.put_header("dpop", dpop_token)

     

       377
       377
       +
           |> Req.request()

     

       378
       378
       +
           |> case do

     

       379
       379
       +
             {:ok, resp} ->

     

       380
       380
       +
               dpop_nonce =

     

       381
       381
       +
                 case resp.headers["dpop-nonce"] do

     

       382
       382
       +
                   [new_nonce | _] -> new_nonce

     

       383
       383
       +
                   _ -> nonce

     

       384
       384
       +
                 end

     

       385
       385
       +
       

     

       386
       386
       +
               cond do

     

       387
       387
       +
                 resp.status == 200 ->

     

       388
       388
       +
                   {:ok, resp.body, dpop_nonce}

     

       389
       389
       +
       

     

       390
       390
       +
                 resp.body["error"] === "use_dpop_nonce" ->

     

       391
       391
       +
                   dpop_token = create_dpop_token(dpop_key, request, dpop_nonce)

     

       392
       392
       +
       

     

       393
       393
       +
                   request

     

       394
       394
       +
                   |> Req.Request.put_header("dpop", dpop_token)

     

       395
       395
       +
                   |> Req.request()

     

       396
       396
       +
                   |> case do

     

       397
       397
       +
                     {:ok, %{status: 200, body: body}} ->

     

       398
       398
       +
                       {:ok, body, dpop_nonce}

     

       399
       399
       +
       

     

       400
       400
       +
                     {:ok, %{body: %{"error" => error, "error_description" => error_description}}} ->

     

       401
       401
       +
                       {:error, {:oauth_error, error, error_description}, dpop_nonce}

     

       402
       402
       +
       

     

       403
       403
       +
                     {:ok, _} ->

     

       404
       404
       +
                       {:error, :unexpected_response, dpop_nonce}

     

       405
       405
       +
       

     

       406
       406
       +
                     {:error, err} ->

     

       407
       407
       +
                       {:error, err, dpop_nonce}

     

       408
       408
       +
                   end

     

       409
       409
       +
       

     

       410
       410
       +
                 true ->

     

       411
       411
       +
                   {:error, {:oauth_error, resp.body["error"], resp.body["error_description"]},

     

       412
       412
       +
                    dpop_nonce}

     

       413
       413
       +
               end

     

       414
       414
       +
       

     

       415
       415
       +
             {:error, err} ->

     

       416
       416
       +
               {:error, err, nonce}

     

       417
       417
       +
           end

     

       418
       418
       +
         end

     

       419
       419
       +
       

     

       420
       420
       +
         @spec request_protected_dpop_resource(

     

       421
       421
       +
                 Req.Request.t(),

     

       422
       422
       +
                 String.t(),

     

       423
       423
       +
                 String.t(),

     

       424
       424
       +
                 JOSE.JWK.t(),

     

       425
       425
       +
                 String.t() | nil

     

       426
       426
       +
               ) :: {:ok, Req.Response.t(), String.t() | nil} | {:error, any()}

     

       427
       427
       +
         def request_protected_dpop_resource(request, issuer, access_token, dpop_key, nonce \\ nil) do

     

       428
       428
       +
           access_token_hash = :crypto.hash(:sha256, access_token) |> Base.url_encode64(padding: false)

     

       429
       429
       +
           # access_token_hash = Base.url_encode64(access_token, padding: false)

     

       430
       430
       +
       

     

       431
       431
       +
           dpop_token =

     

       432
       432
       +
             create_dpop_token(dpop_key, request, nonce, %{iss: issuer, ath: access_token_hash})

     

       433
       433
       +
       

     

       434
       434
       +
           request

     

       435
       435
       +
           |> Req.Request.put_header("dpop", dpop_token)

     

       436
       436
       +
           |> Req.request()

     

       437
       437
       +
           |> case do

     

       438
       438
       +
             {:ok, resp} ->

     

       439
       439
       +
               dpop_nonce =

     

       440
       440
       +
                 case resp.headers["dpop-nonce"] do

     

       441
       441
       +
                   [new_nonce | _] -> new_nonce

     

       442
       442
       +
                   _ -> nonce

     

       443
       443
       +
                 end

     

       444
       444
       +
       

     

       445
       445
       +
               www_authenticate = Req.Response.get_header(resp, "www-authenticate")

     

       446
       446
       +
       

     

       447
       447
       +
               www_dpop_problem =

     

       448
       448
       +
                 www_authenticate != [] && String.starts_with?(Enum.at(www_authenticate, 0), "DPoP")

     

       449
       449
       +
       

     

       450
       450
       +
               if resp.status != 401 || !www_dpop_problem do

     

       451
       451
       +
                 {:ok, resp, dpop_nonce}

     

       452
       452
       +
               else

     

       453
       453
       +
                 dpop_token =

     

       454
       454
       +
                   create_dpop_token(dpop_key, request, dpop_nonce, %{

     

       455
       455
       +
                     iss: issuer,

     

       456
       456
       +
                     ath: access_token_hash

     

       457
       457
       +
                   })

     

       458
       458
       +
       

     

       459
       459
       +
                 request

     

       460
       460
       +
                 |> Req.Request.put_header("dpop", dpop_token)

     

       461
       461
       +
                 |> Req.request()

     

       462
       462
       +
                 |> case do

     

       463
       463
       +
                   {:ok, resp} ->

     

       464
       464
       +
                     dpop_nonce =

     

       465
       465
       +
                       case resp.headers["dpop-nonce"] do

     

       466
       466
       +
                         [new_nonce | _] -> new_nonce

     

       467
       467
       +
                         _ -> dpop_nonce

     

       468
       468
       +
                       end

     

       469
       469
       +
       

     

       470
       470
       +
                     {:ok, resp, dpop_nonce}

     

       471
       471
       +
       

     

       472
       472
       +
                   err ->

     

       473
       473
       +
                     err

     

       474
       474
       +
                 end

     

       475
       475
       +
               end

     

       476
       476
       +
       

     

       477
       477
       +
             err ->

     

       478
       478
       +
               err

     

       479
       479
       +
           end

     

       480
       480
       +
         end

     

       481
       481
       +
       

     

       482
       482
       +
         @spec create_client_assertion(JOSE.JWK.t(), String.t(), String.t()) :: String.t()

     

       483
       483
       +
         def create_client_assertion(jwk, client_id, issuer) do

     

       484
       484
       +
           iat = System.os_time(:second)

     

       485
       485
       +
           jti = random_b64(20)

     

       486
       486
       +
           jws = %{"alg" => "ES256", "kid" => jwk.fields["kid"]}

     

       487
       487
       +
       

     

       488
       488
       +
           jwt = %{

     

       489
       489
       +
             iss: client_id,

     

       490
       490
       +
             sub: client_id,

     

       491
       491
       +
             aud: issuer,

     

       492
       492
       +
             jti: jti,

     

       493
       493
       +
             iat: iat,

     

       494
       494
       +
             exp: iat + 60

     

       495
       495
       +
           }

     

       496
       496
       +
       

     

       497
       497
       +
           JOSE.JWT.sign(jwk, jws, jwt)

     

       498
       498
       +
           |> JOSE.JWS.compact()

     

       499
       499
       +
           |> elem(1)

     

       500
       500
       +
         end

     

       501
       501
       +
       

     

       502
       502
       +
         @spec create_dpop_token(JOSE.JWK.t(), Req.Request.t(), any(), map()) :: String.t()

     

       503
       503
       +
         def create_dpop_token(jwk, request, nonce \\ nil, attrs \\ %{}) do

     

       504
       504
       +
           iat = System.os_time(:second)

     

       505
       505
       +
           jti = random_b64(20)

     

       506
       506
       +
           {_, public_jwk} = JOSE.JWK.to_public_map(jwk)

     

       507
       507
       +
           jws = %{"alg" => "ES256", "typ" => "dpop+jwt", "jwk" => public_jwk}

     

       508
       508
       +
           [request_url | _] = request.url |> to_string() |> String.split("?")

     

       509
       509
       +
       

     

       510
       510
       +
           jwt =

     

       511
       511
       +
             Map.merge(attrs, %{

     

       512
       512
       +
               jti: jti,

     

       513
       513
       +
               htm: atom_to_upcase_string(request.method),

     

       514
       514
       +
               htu: request_url,

     

       515
       515
       +
               iat: iat

     

       516
       516
       +
             })

     

       517
       517
       +
             |> then(fn m ->

     

       518
       518
       +
               if nonce, do: Map.put(m, :nonce, nonce), else: m

     

       519
       519
       +
             end)

     

       520
       520
       +
       

     

       521
       521
       +
           JOSE.JWT.sign(jwk, jws, jwt)

     

       522
       522
       +
           |> JOSE.JWS.compact()

     

       523
       523
       +
           |> elem(1)

     

       524
       524
       +
         end

     

       525
       525
       +
       

     

       526
       526
       +
         @doc false

     

       527
       527
       +
         @spec atom_to_upcase_string(atom()) :: String.t()

     

       528
       528
       +
         def atom_to_upcase_string(atom) do

     

       529
       529
       +
           atom |> to_string() |> String.upcase()

     

       530
       530
       +
         end

     

       531
       531
       +
       end

+40

lib/atex/peri.ex

···

       1
       1
       +
       defmodule Atex.Peri do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Custom validators for Peri, for use within atex.

     

       4
       4
       +
         """

     

       5
       5
       +
       

     

       6
       6
       +
         def uri, do: {:custom, &validate_uri/1}

     

       7
       7
       +
         def did, do: {:string, {:regex, ~r/^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$/}}

     

       8
       8
       +
       

     

       9
       9
       +
         defp validate_uri(uri) when is_binary(uri) do

     

       10
       10
       +
           case URI.new(uri) do

     

       11
       11
       +
             {:ok, _} -> :ok

     

       12
       12
       +
             {:error, _} -> {:error, "must be a valid URI", [uri: uri]}

     

       13
       13
       +
           end

     

       14
       14
       +
         end

     

       15
       15
       +
       

     

       16
       16
       +
         defp validate_uri(uri), do: {:error, "must be a valid URI", [uri: uri]}

     

       17
       17
       +
       

     

       18
       18
       +
         def validate_map(value, schema, extra_keys_schema) when is_map(value) and is_map(schema) do

     

       19
       19
       +
           extra_keys =

     

       20
       20
       +
             Enum.reduce(Map.keys(schema), MapSet.new(Map.keys(value)), fn key, acc ->

     

       21
       21
       +
               acc |> MapSet.delete(key) |> MapSet.delete(to_string(key))

     

       22
       22
       +
             end)

     

       23
       23
       +
       

     

       24
       24
       +
           extra_data =

     

       25
       25
       +
             value

     

       26
       26
       +
             |> Enum.filter(fn {key, _} -> MapSet.member?(extra_keys, key) end)

     

       27
       27
       +
             |> Map.new()

     

       28
       28
       +
       

     

       29
       29
       +
           with {:ok, schema_data} <- Peri.validate(schema, value),

     

       30
       30
       +
                {:ok, extra_data} <- Peri.validate(extra_keys_schema, extra_data) do

     

       31
       31
       +
             {:ok, Map.merge(schema_data, extra_data)}

     

       32
       32
       +
           else

     

       33
       33
       +
             {:error, %Peri.Error{} = err} -> {:error, [err]}

     

       34
       34
       +
             e -> e

     

       35
       35
       +
           end

     

       36
       36
       +
         end

     

       37
       37
       +
       

     

       38
       38
       +
         def validate_map(value, _schema, _extra_keys_schema),

     

       39
       39
       +
           do: {:error, "must be a map", [value: value]}

     

       40
       40
       +
       end

+189

lib/atex/tid.ex

···

       1
       1
       +
       defmodule Atex.TID do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Struct and helper functions for dealing with AT Protocol TIDs (Timestamp

     

       4
       4
       +
         Identifiers), a 13-character string representation of a 64-bit number

     

       5
       5
       +
         comprised of a Unix timestamp (in microsecond precision) and a random "clock

     

       6
       6
       +
         identifier" to help avoid collisions.

     

       7
       7
       +
       

     

       8
       8
       +
         ATProto spec: https://atproto.com/specs/tid

     

       9
       9
       +
       

     

       10
       10
       +
         TID strings are always 13 characters long. All bits in the 64-bit number are

     

       11
       11
       +
         encoded, essentially meaning that the string is padded with "2" if necessary,

     

       12
       12
       +
         (the 0th character in the base32-sortable alphabet).

     

       13
       13
       +
         """

     

       14
       14
       +
         import Bitwise

     

       15
       15
       +
         alias Atex.Base32Sortable

     

       16
       16
       +
         use TypedStruct

     

       17
       17
       +
       

     

       18
       18
       +
         @re ~r/^[234567abcdefghij][234567abcdefghijklmnopqrstuvwxyz]{12}$/

     

       19
       19
       +
       

     

       20
       20
       +
         @typedoc """

     

       21
       21
       +
         A Unix timestamp representing when the TID was created.

     

       22
       22
       +
         """

     

       23
       23
       +
         @type timestamp() :: integer()

     

       24
       24
       +
       

     

       25
       25
       +
         @typedoc """

     

       26
       26
       +
         An integer to be used for the lower 10 bits of the TID.

     

       27
       27
       +
         """

     

       28
       28
       +
         @type clock_id() :: 0..1023

     

       29
       29
       +
       

     

       30
       30
       +
         typedstruct enforce: true do

     

       31
       31
       +
           field :timestamp, timestamp()

     

       32
       32
       +
           field :clock_id, clock_id()

     

       33
       33
       +
         end

     

       34
       34
       +
       

     

       35
       35
       +
         @doc """

     

       36
       36
       +
         Returns a TID for the current moment in time, along with a random clock ID.

     

       37
       37
       +
         """

     

       38
       38
       +
         @spec now() :: t()

     

       39
       39
       +
         def now,

     

       40
       40
       +
           do: %__MODULE__{

     

       41
       41
       +
             timestamp: DateTime.utc_now(:microsecond) |> DateTime.to_unix(:microsecond),

     

       42
       42
       +
             clock_id: gen_clock_id()

     

       43
       43
       +
           }

     

       44
       44
       +
       

     

       45
       45
       +
         @doc """

     

       46
       46
       +
         Create a new TID from a `DateTime` or an integer representing a Unix timestamp in microseconds.

     

       47
       47
       +
       

     

       48
       48
       +
         If `clock_id` isn't provided, a random one will be generated.

     

       49
       49
       +
         """

     

       50
       50
       +
         @spec new(DateTime.t() | integer(), integer() | nil) :: t()

     

       51
       51
       +
         def new(source, clock_id \\ nil)

     

       52
       52
       +
       

     

       53
       53
       +
         def new(%DateTime{} = datetime, clock_id),

     

       54
       54
       +
           do: %__MODULE__{

     

       55
       55
       +
             timestamp: DateTime.to_unix(datetime, :microsecond),

     

       56
       56
       +
             clock_id: clock_id || gen_clock_id()

     

       57
       57
       +
           }

     

       58
       58
       +
       

     

       59
       59
       +
         def new(unix, clock_id) when is_integer(unix),

     

       60
       60
       +
           do: %__MODULE__{timestamp: unix, clock_id: clock_id || gen_clock_id()}

     

       61
       61
       +
       

     

       62
       62
       +
         @doc """

     

       63
       63
       +
         Convert a TID struct to an instance of `DateTime`.

     

       64
       64
       +
         """

     

       65
       65
       +
         def to_datetime(%__MODULE__{} = tid), do: DateTime.from_unix(tid.timestamp, :microsecond)

     

       66
       66
       +
       

     

       67
       67
       +
         @doc """

     

       68
       68
       +
         Generate a random integer to be used as a `clock_id`.

     

       69
       69
       +
         """

     

       70
       70
       +
         @spec gen_clock_id() :: clock_id()

     

       71
       71
       +
         def gen_clock_id, do: :rand.uniform(1024) - 1

     

       72
       72
       +
       

     

       73
       73
       +
         @doc """

     

       74
       74
       +
         Decode a TID string into an `Atex.TID` struct, returning an error if it's invalid.

     

       75
       75
       +
       

     

       76
       76
       +
         ## Examples

     

       77
       77
       +
       

     

       78
       78
       +
         Syntactically valid TIDs:

     

       79
       79
       +
       

     

       80
       80
       +
             iex> Atex.TID.decode("3jzfcijpj2z2a")

     

       81
       81
       +
             {:ok, %Atex.TID{clock_id: 6, timestamp: 1688137381887007}}

     

       82
       82
       +
       

     

       83
       83
       +
             iex> Atex.TID.decode("7777777777777")

     

       84
       84
       +
             {:ok, %Atex.TID{clock_id: 165, timestamp: 5811096293381285}}

     

       85
       85
       +
       

     

       86
       86
       +
             iex> Atex.TID.decode("3zzzzzzzzzzzz")

     

       87
       87
       +
             {:ok, %Atex.TID{clock_id: 1023, timestamp: 2251799813685247}}

     

       88
       88
       +
       

     

       89
       89
       +
             iex> Atex.TID.decode("2222222222222")

     

       90
       90
       +
             {:ok, %Atex.TID{clock_id: 0, timestamp: 0}}

     

       91
       91
       +
       

     

       92
       92
       +
         Invalid TIDs:

     

       93
       93
       +
       

     

       94
       94
       +
             # not base32

     

       95
       95
       +
             iex> Atex.TID.decode("3jzfcijpj2z21")

     

       96
       96
       +
             :error

     

       97
       97
       +
             iex> Atex.TID.decode("0000000000000")

     

       98
       98
       +
             :error

     

       99
       99
       +
       

     

       100
       100
       +
             # case-sensitive

     

       101
       101
       +
             iex> Atex.TID.decode("3JZFCIJPJ2Z2A")

     

       102
       102
       +
             :error

     

       103
       103
       +
       

     

       104
       104
       +
             # too long/short

     

       105
       105
       +
             iex> Atex.TID.decode("3jzfcijpj2z2aa")

     

       106
       106
       +
             :error

     

       107
       107
       +
             iex> Atex.TID.decode("3jzfcijpj2z2")

     

       108
       108
       +
             :error

     

       109
       109
       +
             iex> Atex.TID.decode("222")

     

       110
       110
       +
             :error

     

       111
       111
       +
       

     

       112
       112
       +
             # legacy dash syntax *not* supported (TTTT-TTT-TTTT-CC)

     

       113
       113
       +
             iex> Atex.TID.decode("3jzf-cij-pj2z-2a")

     

       114
       114
       +
             :error

     

       115
       115
       +
       

     

       116
       116
       +
             # high bit can't be set

     

       117
       117
       +
             iex> Atex.TID.decode("zzzzzzzzzzzzz")

     

       118
       118
       +
             :error

     

       119
       119
       +
             iex> Atex.TID.decode("kjzfcijpj2z2a")

     

       120
       120
       +
             :error

     

       121
       121
       +
       

     

       122
       122
       +
         """

     

       123
       123
       +
         @spec decode(String.t()) :: {:ok, t()} | :error

     

       124
       124
       +
         def decode(<<timestamp::binary-size(11), clock_id::binary-size(2)>> = tid) do

     

       125
       125
       +
           if match?(tid) do

     

       126
       126
       +
             timestamp = Base32Sortable.decode(timestamp)

     

       127
       127
       +
             clock_id = Base32Sortable.decode(clock_id)

     

       128
       128
       +
       

     

       129
       129
       +
             {:ok,

     

       130
       130
       +
              %__MODULE__{

     

       131
       131
       +
                timestamp: timestamp,

     

       132
       132
       +
                clock_id: clock_id

     

       133
       133
       +
              }}

     

       134
       134
       +
           else

     

       135
       135
       +
             :error

     

       136
       136
       +
           end

     

       137
       137
       +
         end

     

       138
       138
       +
       

     

       139
       139
       +
         def decode(_tid), do: :error

     

       140
       140
       +
       

     

       141
       141
       +
         @doc """

     

       142
       142
       +
         Encode a TID struct into a string.

     

       143
       143
       +
       

     

       144
       144
       +
         ## Examples

     

       145
       145
       +
       

     

       146
       146
       +
             iex> Atex.TID.encode(%Atex.TID{clock_id: 6, timestamp: 1688137381887007})

     

       147
       147
       +
             "3jzfcijpj2z2a"

     

       148
       148
       +
       

     

       149
       149
       +
             iex> Atex.TID.encode(%Atex.TID{clock_id: 165, timestamp: 5811096293381285})

     

       150
       150
       +
             "7777777777777"

     

       151
       151
       +
       

     

       152
       152
       +
             iex> Atex.TID.encode(%Atex.TID{clock_id: 1023, timestamp: 2251799813685247})

     

       153
       153
       +
             "3zzzzzzzzzzzz"

     

       154
       154
       +
       

     

       155
       155
       +
             iex> Atex.TID.encode(%Atex.TID{clock_id: 0, timestamp: 0})

     

       156
       156
       +
             "2222222222222"

     

       157
       157
       +
       

     

       158
       158
       +
         """

     

       159
       159
       +
         @spec encode(t()) :: String.t()

     

       160
       160
       +
         def encode(%__MODULE__{} = tid) do

     

       161
       161
       +
           timestamp = tid.timestamp |> Base32Sortable.encode() |> String.pad_leading(11, "2")

     

       162
       162
       +
           clock_id = (tid.clock_id &&& 1023) |> Base32Sortable.encode() |> String.pad_leading(2, "2")

     

       163
       163
       +
           timestamp <> clock_id

     

       164
       164
       +
         end

     

       165
       165
       +
       

     

       166
       166
       +
         @doc """

     

       167
       167
       +
         Check if a given string matches the format for a TID.

     

       168
       168
       +
       

     

       169
       169
       +
         ## Examples

     

       170
       170
       +
       

     

       171
       171
       +
           iex> Atex.TID.match?("3jzfcijpj2z2a")

     

       172
       172
       +
           true

     

       173
       173
       +
       

     

       174
       174
       +
           iex> Atex.TID.match?("2222222222222")

     

       175
       175
       +
           true

     

       176
       176
       +
       

     

       177
       177
       +
           iex> Atex.TID.match?("banana")

     

       178
       178
       +
           false

     

       179
       179
       +
       

     

       180
       180
       +
           iex> Atex.TID.match?("kjzfcijpj2z2a")

     

       181
       181
       +
           false

     

       182
       182
       +
         """

     

       183
       183
       +
         @spec match?(String.t()) :: boolean()

     

       184
       184
       +
         def match?(value), do: Regex.match?(@re, value)

     

       185
       185
       +
       end

     

       186
       186
       +
       

     

       187
       187
       +
       defimpl String.Chars, for: Atex.TID do

     

       188
       188
       +
         def to_string(tid), do: Atex.TID.encode(tid)

     

       189
       189
       +
       end

+31

lib/atex/xrpc/client.ex

···

       1
       1
       +
       defmodule Atex.XRPC.Client do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Behaviour that defines the interface for XRPC clients.

     

       4
       4
       +
       

     

       5
       5
       +
         This behaviour allows different types of clients (login-based, OAuth-based, etc.)

     

       6
       6
       +
         to implement authentication and request handling while maintaining a consistent interface.

     

       7
       7
       +
       

     

       8
       8
       +
         Implementations must handle token refresh internally when requests fail due to

     

       9
       9
       +
         expired tokens, and return both the result and potentially updated client state.

     

       10
       10
       +
         """

     

       11
       11
       +
       

     

       12
       12
       +
         @type client :: struct()

     

       13
       13
       +
         @type request_opts :: keyword()

     

       14
       14
       +
         @type request_result :: {:ok, Req.Response.t(), client()} | {:error, any(), client()}

     

       15
       15
       +
       

     

       16
       16
       +
         @doc """

     

       17
       17
       +
         Perform an authenticated HTTP GET request on an XRPC resource.

     

       18
       18
       +
       

     

       19
       19
       +
         Implementations should handle token refresh if the request fails due to

     

       20
       20
       +
         expired authentication, returning both the response and the (potentially updated) client.

     

       21
       21
       +
         """

     

       22
       22
       +
         @callback get(client(), String.t(), request_opts()) :: request_result()

     

       23
       23
       +
       

     

       24
       24
       +
         @doc """

     

       25
       25
       +
         Perform an authenticated HTTP POST request on an XRPC resource.

     

       26
       26
       +
       

     

       27
       27
       +
         Implementations should handle token refresh if the request fails due to

     

       28
       28
       +
         expired authentication, returning both the response and the (potentially updated) client.

     

       29
       29
       +
         """

     

       30
       30
       +
         @callback post(client(), String.t(), request_opts()) :: request_result()

     

       31
       31
       +
       end

+148

lib/atex/xrpc/login_client.ex

···

       1
       1
       +
       defmodule Atex.XRPC.LoginClient do

     

       2
       2
       +
         alias Atex.XRPC

     

       3
       3
       +
         use TypedStruct

     

       4
       4
       +
       

     

       5
       5
       +
         @behaviour Atex.XRPC.Client

     

       6
       6
       +
       

     

       7
       7
       +
         typedstruct do

     

       8
       8
       +
           field :endpoint, String.t(), enforce: true

     

       9
       9
       +
           field :access_token, String.t() | nil

     

       10
       10
       +
           field :refresh_token, String.t() | nil

     

       11
       11
       +
         end

     

       12
       12
       +
       

     

       13
       13
       +
         @doc """

     

       14
       14
       +
         Create a new `Atex.XRPC.LoginClient` from an endpoint, and optionally an

     

       15
       15
       +
         existing access/refresh token.

     

       16
       16
       +
       

     

       17
       17
       +
         Endpoint should be the base URL of a PDS, or an AppView in the case of

     

       18
       18
       +
         unauthenticated requests (like Bluesky's public API), e.g.

     

       19
       19
       +
         `https://bsky.social`.

     

       20
       20
       +
         """

     

       21
       21
       +
         @spec new(String.t(), String.t() | nil, String.t() | nil) :: t()

     

       22
       22
       +
         def new(endpoint, access_token \\ nil, refresh_token \\ nil) do

     

       23
       23
       +
           %__MODULE__{endpoint: endpoint, access_token: access_token, refresh_token: refresh_token}

     

       24
       24
       +
         end

     

       25
       25
       +
       

     

       26
       26
       +
         @doc """

     

       27
       27
       +
         Create a new `Atex.XRPC.LoginClient` by logging in with an `identifier` and

     

       28
       28
       +
         `password` to fetch an initial pair of access & refresh tokens.

     

       29
       29
       +
       

     

       30
       30
       +
         Also supports providing a MFA token in the situation that is required.

     

       31
       31
       +
       

     

       32
       32
       +
         Uses `com.atproto.server.createSession` under the hood, so `identifier` can be

     

       33
       33
       +
         either a handle or a DID.

     

       34
       34
       +
       

     

       35
       35
       +
         ## Examples

     

       36
       36
       +
       

     

       37
       37
       +
             iex> Atex.XRPC.LoginClient.login("https://bsky.social", "example.com", "password123")

     

       38
       38
       +
             {:ok, %Atex.XRPC.LoginClient{...}}

     

       39
       39
       +
         """

     

       40
       40
       +
         @spec login(String.t(), String.t(), String.t()) :: {:ok, t()} | {:error, any()}

     

       41
       41
       +
         @spec login(String.t(), String.t(), String.t(), String.t() | nil) ::

     

       42
       42
       +
                 {:ok, t()} | {:error, any()}

     

       43
       43
       +
         def login(endpoint, identifier, password, auth_factor_token \\ nil) do

     

       44
       44
       +
           json =

     

       45
       45
       +
             %{identifier: identifier, password: password}

     

       46
       46
       +
             |> then(

     

       47
       47
       +
               &if auth_factor_token do

     

       48
       48
       +
                 Map.merge(&1, %{authFactorToken: auth_factor_token})

     

       49
       49
       +
               else

     

       50
       50
       +
                 &1

     

       51
       51
       +
               end

     

       52
       52
       +
             )

     

       53
       53
       +
       

     

       54
       54
       +
           response = XRPC.unauthed_post(endpoint, "com.atproto.server.createSession", json: json)

     

       55
       55
       +
       

     

       56
       56
       +
           case response do

     

       57
       57
       +
             {:ok, %{body: %{"accessJwt" => access_token, "refreshJwt" => refresh_token}}} ->

     

       58
       58
       +
               {:ok, new(endpoint, access_token, refresh_token)}

     

       59
       59
       +
       

     

       60
       60
       +
             err ->

     

       61
       61
       +
               err

     

       62
       62
       +
           end

     

       63
       63
       +
         end

     

       64
       64
       +
       

     

       65
       65
       +
         @doc """

     

       66
       66
       +
         Request a new `refresh_token` for the given client.

     

       67
       67
       +
         """

     

       68
       68
       +
         @spec refresh(t()) :: {:ok, t()} | {:error, any()}

     

       69
       69
       +
         def refresh(%__MODULE__{endpoint: endpoint, refresh_token: refresh_token} = client) do

     

       70
       70
       +
           request =

     

       71
       71
       +
             Req.new(method: :post, url: XRPC.url(endpoint, "com.atproto.server.refreshSession"))

     

       72
       72
       +
             |> put_auth(refresh_token)

     

       73
       73
       +
       

     

       74
       74
       +
           case Req.request(request) do

     

       75
       75
       +
             {:ok, %{body: %{"accessJwt" => access_token, "refreshJwt" => refresh_token}}} ->

     

       76
       76
       +
               {:ok, %{client | access_token: access_token, refresh_token: refresh_token}}

     

       77
       77
       +
       

     

       78
       78
       +
             {:ok, response} ->

     

       79
       79
       +
               {:error, response}

     

       80
       80
       +
       

     

       81
       81
       +
             err ->

     

       82
       82
       +
               err

     

       83
       83
       +
           end

     

       84
       84
       +
         end

     

       85
       85
       +
       

     

       86
       86
       +
         @impl true

     

       87
       87
       +
         def get(%__MODULE__{} = client, resource, opts \\ []) do

     

       88
       88
       +
           request(client, opts ++ [method: :get, url: XRPC.url(client.endpoint, resource)])

     

       89
       89
       +
         end

     

       90
       90
       +
       

     

       91
       91
       +
         @impl true

     

       92
       92
       +
         def post(%__MODULE__{} = client, resource, opts \\ []) do

     

       93
       93
       +
           request(client, opts ++ [method: :post, url: XRPC.url(client.endpoint, resource)])

     

       94
       94
       +
         end

     

       95
       95
       +
       

     

       96
       96
       +
         @spec request(t(), keyword()) :: {:ok, Req.Response.t(), t()} | {:error, any()}

     

       97
       97
       +
         defp request(client, opts) do

     

       98
       98
       +
           with {:ok, client} <- validate_client(client) do

     

       99
       99
       +
             request = opts |> Req.new() |> put_auth(client.access_token)

     

       100
       100
       +
       

     

       101
       101
       +
             case Req.request(request) do

     

       102
       102
       +
               {:ok, %{status: 200} = response} ->

     

       103
       103
       +
                 {:ok, response, client}

     

       104
       104
       +
       

     

       105
       105
       +
               {:ok, response} ->

     

       106
       106
       +
                 handle_failure(client, response, request)

     

       107
       107
       +
       

     

       108
       108
       +
               err ->

     

       109
       109
       +
                 err

     

       110
       110
       +
             end

     

       111
       111
       +
           end

     

       112
       112
       +
         end

     

       113
       113
       +
       

     

       114
       114
       +
         @spec handle_failure(t(), Req.Response.t(), Req.Request.t()) ::

     

       115
       115
       +
                 {:ok, Req.Response.t(), t()} | {:error, any()}

     

       116
       116
       +
         defp handle_failure(client, response, request) do

     

       117
       117
       +
           IO.inspect(response, label: "got failure")

     

       118
       118
       +
       

     

       119
       119
       +
           if auth_error?(response.body) and client.refresh_token do

     

       120
       120
       +
             case refresh(client) do

     

       121
       121
       +
               {:ok, client} ->

     

       122
       122
       +
                 case Req.request(put_auth(request, client.access_token)) do

     

       123
       123
       +
                   {:ok, %{status: 200} = response} -> {:ok, response, client}

     

       124
       124
       +
                   {:ok, response} -> {:error, response}

     

       125
       125
       +
                   err -> err

     

       126
       126
       +
                 end

     

       127
       127
       +
       

     

       128
       128
       +
               err ->

     

       129
       129
       +
                 err

     

       130
       130
       +
             end

     

       131
       131
       +
           else

     

       132
       132
       +
             {:error, response}

     

       133
       133
       +
           end

     

       134
       134
       +
         end

     

       135
       135
       +
       

     

       136
       136
       +
         @spec validate_client(t()) :: {:ok, t()} | {:error, any()}

     

       137
       137
       +
         defp validate_client(%__MODULE__{access_token: nil}), do: {:error, :no_token}

     

       138
       138
       +
         defp validate_client(%__MODULE__{} = client), do: {:ok, client}

     

       139
       139
       +
       

     

       140
       140
       +
         @spec auth_error?(body :: Req.Response.t()) :: boolean()

     

       141
       141
       +
         defp auth_error?(%{status: status}) when status in [401, 403], do: true

     

       142
       142
       +
         defp auth_error?(%{body: %{"error" => "InvalidToken"}}), do: true

     

       143
       143
       +
         defp auth_error?(_response), do: false

     

       144
       144
       +
       

     

       145
       145
       +
         @spec put_auth(Req.Request.t(), String.t()) :: Req.Request.t()

     

       146
       146
       +
         defp put_auth(request, token),

     

       147
       147
       +
           do: Req.Request.put_header(request, "authorization", "Bearer #{token}")

     

       148
       148
       +
       end

+228

lib/atex/xrpc/oauth_client.ex

···

       1
       1
       +
       defmodule Atex.XRPC.OAuthClient do

     

       2
       2
       +
         alias Atex.OAuth

     

       3
       3
       +
         alias Atex.XRPC

     

       4
       4
       +
         use TypedStruct

     

       5
       5
       +
       

     

       6
       6
       +
         @behaviour Atex.XRPC.Client

     

       7
       7
       +
       

     

       8
       8
       +
         typedstruct enforce: true do

     

       9
       9
       +
           field :endpoint, String.t()

     

       10
       10
       +
           field :issuer, String.t()

     

       11
       11
       +
           field :access_token, String.t()

     

       12
       12
       +
           field :refresh_token, String.t()

     

       13
       13
       +
           field :did, String.t()

     

       14
       14
       +
           field :expires_at, NaiveDateTime.t()

     

       15
       15
       +
           field :dpop_nonce, String.t() | nil, enforce: false

     

       16
       16
       +
           field :dpop_key, JOSE.JWK.t()

     

       17
       17
       +
         end

     

       18
       18
       +
       

     

       19
       19
       +
         @doc """

     

       20
       20
       +
         Create a new OAuthClient struct.

     

       21
       21
       +
         """

     

       22
       22
       +
         @spec new(

     

       23
       23
       +
                 String.t(),

     

       24
       24
       +
                 String.t(),

     

       25
       25
       +
                 String.t(),

     

       26
       26
       +
                 String.t(),

     

       27
       27
       +
                 NaiveDateTime.t(),

     

       28
       28
       +
                 JOSE.JWK.t(),

     

       29
       29
       +
                 String.t() | nil

     

       30
       30
       +
               ) :: t()

     

       31
       31
       +
         def new(endpoint, did, access_token, refresh_token, expires_at, dpop_key, dpop_nonce) do

     

       32
       32
       +
           {:ok, issuer} = OAuth.get_authorization_server(endpoint)

     

       33
       33
       +
       

     

       34
       34
       +
           %__MODULE__{

     

       35
       35
       +
             endpoint: endpoint,

     

       36
       36
       +
             issuer: issuer,

     

       37
       37
       +
             access_token: access_token,

     

       38
       38
       +
             refresh_token: refresh_token,

     

       39
       39
       +
             did: did,

     

       40
       40
       +
             expires_at: expires_at,

     

       41
       41
       +
             dpop_nonce: dpop_nonce,

     

       42
       42
       +
             dpop_key: dpop_key

     

       43
       43
       +
           }

     

       44
       44
       +
         end

     

       45
       45
       +
       

     

       46
       46
       +
         @doc """

     

       47
       47
       +
         Create an OAuthClient struct from a `Plug.Conn`.

     

       48
       48
       +
       

     

       49
       49
       +
         Requires the conn to have passed through `Plug.Session` and

     

       50
       50
       +
         `Plug.Conn.fetch_session/2` so that the session can be acquired and have the

     

       51
       51
       +
         `atex_oauth` key fetched from it.

     

       52
       52
       +
       

     

       53
       53
       +
         Returns `:error` if the state is missing or is not the expected shape.

     

       54
       54
       +
         """

     

       55
       55
       +
         @spec from_conn(Plug.Conn.t()) :: {:ok, t()} | :error

     

       56
       56
       +
         def from_conn(%Plug.Conn{} = conn) do

     

       57
       57
       +
           oauth_state = Plug.Conn.get_session(conn, :atex_oauth)

     

       58
       58
       +
       

     

       59
       59
       +
           case oauth_state do

     

       60
       60
       +
             %{

     

       61
       61
       +
               access_token: access_token,

     

       62
       62
       +
               refresh_token: refresh_token,

     

       63
       63
       +
               did: did,

     

       64
       64
       +
               pds: pds,

     

       65
       65
       +
               expires_at: expires_at,

     

       66
       66
       +
               dpop_nonce: dpop_nonce,

     

       67
       67
       +
               dpop_key: dpop_key

     

       68
       68
       +
             } ->

     

       69
       69
       +
               {:ok, new(pds, did, access_token, refresh_token, expires_at, dpop_key, dpop_nonce)}

     

       70
       70
       +
       

     

       71
       71
       +
             _ ->

     

       72
       72
       +
               :error

     

       73
       73
       +
           end

     

       74
       74
       +
         end

     

       75
       75
       +
       

     

       76
       76
       +
         @doc """

     

       77
       77
       +
         Updates a `Plug.Conn` session with the latest values from the client.

     

       78
       78
       +
       

     

       79
       79
       +
         Ideally should be called at the end of routes where XRPC calls occur, in case

     

       80
       80
       +
         the client has transparently refreshed, so that the user is always up to date.

     

       81
       81
       +
         """

     

       82
       82
       +
         @spec update_plug(Plug.Conn.t(), t()) :: Plug.Conn.t()

     

       83
       83
       +
         def update_plug(%Plug.Conn{} = conn, %__MODULE__{} = client) do

     

       84
       84
       +
           Plug.Conn.put_session(conn, :atex_oauth, %{

     

       85
       85
       +
             access_token: client.access_token,

     

       86
       86
       +
             refresh_token: client.refresh_token,

     

       87
       87
       +
             did: client.did,

     

       88
       88
       +
             pds: client.endpoint,

     

       89
       89
       +
             expires_at: client.expires_at,

     

       90
       90
       +
             dpop_nonce: client.dpop_nonce,

     

       91
       91
       +
             dpop_key: client.dpop_key

     

       92
       92
       +
           })

     

       93
       93
       +
         end

     

       94
       94
       +
       

     

       95
       95
       +
         @doc """

     

       96
       96
       +
         Ask the client's OAuth server for a new set of auth tokens.

     

       97
       97
       +
       

     

       98
       98
       +
         You shouldn't need to call this manually for the most part, the client does

     

       99
       99
       +
         it's best to refresh automatically when it needs to.

     

       100
       100
       +
         """

     

       101
       101
       +
         @spec refresh(t()) :: {:ok, t()} | {:error, any()}

     

       102
       102
       +
         def refresh(%__MODULE__{} = client) do

     

       103
       103
       +
           with {:ok, authz_server} <- OAuth.get_authorization_server(client.endpoint),

     

       104
       104
       +
                {:ok, %{token_endpoint: token_endpoint}} <-

     

       105
       105
       +
                  OAuth.get_authorization_server_metadata(authz_server) do

     

       106
       106
       +
             case OAuth.refresh_token(

     

       107
       107
       +
                    client.refresh_token,

     

       108
       108
       +
                    client.dpop_key,

     

       109
       109
       +
                    client.issuer,

     

       110
       110
       +
                    token_endpoint

     

       111
       111
       +
                  ) do

     

       112
       112
       +
               {:ok, tokens, nonce} ->

     

       113
       113
       +
                 {:ok,

     

       114
       114
       +
                  %{

     

       115
       115
       +
                    client

     

       116
       116
       +
                    | access_token: tokens.access_token,

     

       117
       117
       +
                      refresh_token: tokens.refresh_token,

     

       118
       118
       +
                      dpop_nonce: nonce

     

       119
       119
       +
                  }}

     

       120
       120
       +
       

     

       121
       121
       +
               err ->

     

       122
       122
       +
                 err

     

       123
       123
       +
             end

     

       124
       124
       +
           end

     

       125
       125
       +
         end

     

       126
       126
       +
       

     

       127
       127
       +
         @doc """

     

       128
       128
       +
         See `Atex.XRPC.get/3`.

     

       129
       129
       +
         """

     

       130
       130
       +
         @impl true

     

       131
       131
       +
         def get(%__MODULE__{} = client, resource, opts \\ []) do

     

       132
       132
       +
           request(client, opts ++ [method: :get, url: XRPC.url(client.endpoint, resource)])

     

       133
       133
       +
         end

     

       134
       134
       +
       

     

       135
       135
       +
         @doc """

     

       136
       136
       +
         See `Atex.XRPC.post/3`.

     

       137
       137
       +
         """

     

       138
       138
       +
         @impl true

     

       139
       139
       +
         def post(%__MODULE__{} = client, resource, opts \\ []) do

     

       140
       140
       +
           request(client, opts ++ [method: :post, url: XRPC.url(client.endpoint, resource)])

     

       141
       141
       +
         end

     

       142
       142
       +
       

     

       143
       143
       +
         @spec request(t(), keyword()) :: {:ok, Req.Response.t(), t()} | {:error, any(), any()}

     

       144
       144
       +
         defp request(client, opts) do

     

       145
       145
       +
           # Preemptively refresh token if it's about to expire

     

       146
       146
       +
           with {:ok, client} <- maybe_refresh(client) do

     

       147
       147
       +
             request = opts |> Req.new() |> put_auth(client.access_token)

     

       148
       148
       +
       

     

       149
       149
       +
             case OAuth.request_protected_dpop_resource(

     

       150
       150
       +
                    request,

     

       151
       151
       +
                    client.issuer,

     

       152
       152
       +
                    client.access_token,

     

       153
       153
       +
                    client.dpop_key,

     

       154
       154
       +
                    client.dpop_nonce

     

       155
       155
       +
                  ) do

     

       156
       156
       +
               {:ok, %{status: 200} = response, nonce} ->

     

       157
       157
       +
                 client = %{client | dpop_nonce: nonce}

     

       158
       158
       +
                 {:ok, response, client}

     

       159
       159
       +
       

     

       160
       160
       +
               {:ok, response, nonce} ->

     

       161
       161
       +
                 client = %{client | dpop_nonce: nonce}

     

       162
       162
       +
                 handle_failure(client, response, request)

     

       163
       163
       +
       

     

       164
       164
       +
               err ->

     

       165
       165
       +
                 err

     

       166
       166
       +
             end

     

       167
       167
       +
           end

     

       168
       168
       +
         end

     

       169
       169
       +
       

     

       170
       170
       +
         @spec handle_failure(t(), Req.Response.t(), Req.Request.t()) ::

     

       171
       171
       +
                 {:ok, Req.Response.t(), t()} | {:error, any(), t()}

     

       172
       172
       +
         defp handle_failure(client, response, request) do

     

       173
       173
       +
           IO.inspect(response, label: "got failure")

     

       174
       174
       +
       

     

       175
       175
       +
           if auth_error?(response.body) and client.refresh_token do

     

       176
       176
       +
             case refresh(client) do

     

       177
       177
       +
               {:ok, client} ->

     

       178
       178
       +
                 case OAuth.request_protected_dpop_resource(

     

       179
       179
       +
                        request,

     

       180
       180
       +
                        client.issuer,

     

       181
       181
       +
                        client.access_token,

     

       182
       182
       +
                        client.dpop_key,

     

       183
       183
       +
                        client.dpop_nonce

     

       184
       184
       +
                      ) do

     

       185
       185
       +
                   {:ok, %{status: 200} = response, nonce} ->

     

       186
       186
       +
                     {:ok, response, %{client | dpop_nonce: nonce}}

     

       187
       187
       +
       

     

       188
       188
       +
                   {:ok, response, nonce} ->

     

       189
       189
       +
                     {:error, response, %{client | dpop_nonce: nonce}}

     

       190
       190
       +
       

     

       191
       191
       +
                   {:error, err} ->

     

       192
       192
       +
                     {:error, err, client}

     

       193
       193
       +
                 end

     

       194
       194
       +
       

     

       195
       195
       +
               err ->

     

       196
       196
       +
                 err

     

       197
       197
       +
             end

     

       198
       198
       +
           else

     

       199
       199
       +
             {:error, response, client}

     

       200
       200
       +
           end

     

       201
       201
       +
         end

     

       202
       202
       +
       

     

       203
       203
       +
         @spec maybe_refresh(t(), integer()) :: {:ok, t()} | {:error, any()}

     

       204
       204
       +
         defp maybe_refresh(%__MODULE__{expires_at: expires_at} = client, buffer_minutes \\ 5) do

     

       205
       205
       +
           if token_expiring_soon?(expires_at, buffer_minutes) do

     

       206
       206
       +
             refresh(client)

     

       207
       207
       +
           else

     

       208
       208
       +
             {:ok, client}

     

       209
       209
       +
           end

     

       210
       210
       +
         end

     

       211
       211
       +
       

     

       212
       212
       +
         @spec token_expiring_soon?(NaiveDateTime.t(), integer()) :: boolean()

     

       213
       213
       +
         defp token_expiring_soon?(expires_at, buffer_minutes) do

     

       214
       214
       +
           now = NaiveDateTime.utc_now()

     

       215
       215
       +
           expiry_threshold = NaiveDateTime.add(now, buffer_minutes * 60, :second)

     

       216
       216
       +
       

     

       217
       217
       +
           NaiveDateTime.compare(expires_at, expiry_threshold) in [:lt, :eq]

     

       218
       218
       +
         end

     

       219
       219
       +
       

     

       220
       220
       +
         @spec auth_error?(body :: Req.Response.t()) :: boolean()

     

       221
       221
       +
         defp auth_error?(%{status: status}) when status in [401, 403], do: true

     

       222
       222
       +
         defp auth_error?(%{body: %{"error" => "InvalidToken"}}), do: true

     

       223
       223
       +
         defp auth_error?(_response), do: false

     

       224
       224
       +
       

     

       225
       225
       +
         @spec put_auth(Req.Request.t(), String.t()) :: Req.Request.t()

     

       226
       226
       +
         defp put_auth(request, token),

     

       227
       227
       +
           do: Req.Request.put_header(request, "authorization", "DPoP #{token}")

     

       228
       228
       +
       end

+210

lib/atex/xrpc.ex

···

       1
       1
       +
       defmodule Atex.XRPC do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         XRPC client module for AT Protocol RPC calls.

     

       4
       4
       +
       

     

       5
       5
       +
         This module provides both authenticated and unauthenticated access to AT Protocol

     

       6
       6
       +
         XRPC endpoints. The authenticated functions (`get/3`, `post/3`) work with any

     

       7
       7
       +
         client that implements the `Atex.XRPC.Client`.

     

       8
       8
       +
       

     

       9
       9
       +
         ## Example usage

     

       10
       10
       +
       

     

       11
       11
       +
             # Login-based client

     

       12
       12
       +
             {:ok, client} = Atex.XRPC.LoginClient.login("https://bsky.social", "user.bsky.social", "password")

     

       13
       13
       +
             {:ok, response, client} = Atex.XRPC.get(client, "app.bsky.actor.getProfile", params: [actor: "user.bsky.social"])

     

       14
       14
       +
       

     

       15
       15
       +
             # OAuth-based client

     

       16
       16
       +
             {:ok, oauth_client} = Atex.XRPC.OAuthClient.from_conn(conn)

     

       17
       17
       +
             {:ok, response, oauth_client} = Atex.XRPC.get(oauth_client, "app.bsky.actor.getProfile", params: [actor: "user.bsky.social"])

     

       18
       18
       +
       

     

       19
       19
       +
         ## Unauthenticated requests

     

       20
       20
       +
       

     

       21
       21
       +
         Unauthenticated functions (`unauthed_get/3`, `unauthed_post/3`) do not require a client

     

       22
       22
       +
         and work directly with endpoints:

     

       23
       23
       +
       

     

       24
       24
       +
             {:ok, response} = Atex.XRPC.unauthed_get("https://bsky.social", "com.atproto.sync.getHead", params: [did: "did:plc:..."])

     

       25
       25
       +
         """

     

       26
       26
       +
       

     

       27
       27
       +
         alias Atex.XRPC.Client

     

       28
       28
       +
       

     

       29
       29
       +
         @doc """

     

       30
       30
       +
         Perform a HTTP GET on a XRPC resource. Called a "query" in lexicons.

     

       31
       31
       +
       

     

       32
       32
       +
         Accepts any client that implements `Atex.XRPC.Client` and returns

     

       33
       33
       +
         both the response and the (potentially updated) client.

     

       34
       34
       +
       

     

       35
       35
       +
         Can be called either with the XRPC operation name as a string, or with a lexicon

     

       36
       36
       +
         struct (generated via `deflexicon`) for type safety and automatic parameter/response handling.

     

       37
       37
       +
       

     

       38
       38
       +
         When using a lexicon struct, the response body will be automatically converted to the

     

       39
       39
       +
         corresponding type if an Output struct exists for the lexicon.

     

       40
       40
       +
       

     

       41
       41
       +
         ## Examples

     

       42
       42
       +
       

     

       43
       43
       +
             # Using string XRPC name

     

       44
       44
       +
             {:ok, response, client} =

     

       45
       45
       +
               Atex.XRPC.get(client, "app.bsky.actor.getProfile", params: [actor: "ovyerus.com"])

     

       46
       46
       +
       

     

       47
       47
       +
             # Using lexicon struct with typed construction

     

       48
       48
       +
             {:ok, response, client} =

     

       49
       49
       +
               Atex.XRPC.get(client, %App.Bsky.Actor.GetProfile{

     

       50
       50
       +
                 params: %App.Bsky.Actor.GetProfile.Params{actor: "ovyerus.com"}

     

       51
       51
       +
               })

     

       52
       52
       +
         """

     

       53
       53
       +
         @spec get(Client.client(), String.t() | struct(), keyword()) ::

     

       54
       54
       +
                 {:ok, Req.Response.t(), Client.client()}

     

       55
       55
       +
                 | {:error, any(), Client.client()}

     

       56
       56
       +
         def get(client, name, opts \\ [])

     

       57
       57
       +
       

     

       58
       58
       +
         def get(client, name, opts) when is_binary(name) do

     

       59
       59
       +
           client.__struct__.get(client, name, opts)

     

       60
       60
       +
         end

     

       61
       61
       +
       

     

       62
       62
       +
         def get(client, %{__struct__: module} = query, opts) do

     

       63
       63
       +
           opts = if Map.get(query, :params), do: Keyword.put(opts, :params, query.params), else: opts

     

       64
       64
       +
           output_struct = Module.concat(module, Output)

     

       65
       65
       +
           output_exists = Code.ensure_loaded?(output_struct)

     

       66
       66
       +
       

     

       67
       67
       +
           case client.__struct__.get(client, module.id(), opts) do

     

       68
       68
       +
             {:ok, %{status: 200} = response, client} ->

     

       69
       69
       +
               if output_exists do

     

       70
       70
       +
                 case output_struct.from_json(response.body) do

     

       71
       71
       +
                   {:ok, output} ->

     

       72
       72
       +
                     {:ok, %{response | body: output}, client}

     

       73
       73
       +
       

     

       74
       74
       +
                   err ->

     

       75
       75
       +
                     err

     

       76
       76
       +
                 end

     

       77
       77
       +
               else

     

       78
       78
       +
                 {:ok, response, client}

     

       79
       79
       +
               end

     

       80
       80
       +
       

     

       81
       81
       +
             {:ok, _, _} = ok ->

     

       82
       82
       +
               ok

     

       83
       83
       +
       

     

       84
       84
       +
             err ->

     

       85
       85
       +
               err

     

       86
       86
       +
           end

     

       87
       87
       +
         end

     

       88
       88
       +
       

     

       89
       89
       +
         @doc """

     

       90
       90
       +
         Perform a HTTP POST on a XRPC resource. Called a "procedure" in lexicons.

     

       91
       91
       +
       

     

       92
       92
       +
         Accepts any client that implements `Atex.XRPC.Client` and returns both the

     

       93
       93
       +
         response and the (potentially updated) client.

     

       94
       94
       +
       

     

       95
       95
       +
         Can be called either with the XRPC operation name as a string, or with a

     

       96
       96
       +
         lexicon struct (generated via `deflexicon`) for type safety and automatic

     

       97
       97
       +
         input/parameter mapping.

     

       98
       98
       +
       

     

       99
       99
       +
         When using a lexicon struct, the response body will be automatically converted

     

       100
       100
       +
         to the corresponding type if an Output struct exists for the lexicon.

     

       101
       101
       +
       

     

       102
       102
       +
         ## Examples

     

       103
       103
       +
       

     

       104
       104
       +
             # Using string XRPC name

     

       105
       105
       +
             {:ok, response, client} =

     

       106
       106
       +
               Atex.XRPC.post(

     

       107
       107
       +
                 client,

     

       108
       108
       +
                 "com.atproto.repo.createRecord",

     

       109
       109
       +
                 json: %{

     

       110
       110
       +
                   repo: "did:plc:...",

     

       111
       111
       +
                   collection: "app.bsky.feed.post",

     

       112
       112
       +
                   rkey: Atex.TID.now() |> to_string(),

     

       113
       113
       +
                   record: %{

     

       114
       114
       +
                     text: "Hello World",

     

       115
       115
       +
                     createdAt: NaiveDateTime.to_iso8601(NaiveDateTime.utc_now())

     

       116
       116
       +
                   }

     

       117
       117
       +
                 }

     

       118
       118
       +
               )

     

       119
       119
       +
       

     

       120
       120
       +
             # Using lexicon struct with typed construction

     

       121
       121
       +
             {:ok, response, client} =

     

       122
       122
       +
               Atex.XRPC.post(client, %Com.Atproto.Repo.CreateRecord{

     

       123
       123
       +
                 input: %Com.Atproto.Repo.CreateRecord.Input{

     

       124
       124
       +
                   repo: "did:plc:...",

     

       125
       125
       +
                   collection: "app.bsky.feed.post",

     

       126
       126
       +
                   rkey: Atex.TID.now() |> to_string(),

     

       127
       127
       +
                   record: %App.Bsky.Feed.Post{

     

       128
       128
       +
                     text: "Hello World!",

     

       129
       129
       +
                     createdAt: NaiveDateTime.to_iso8601(NaiveDateTime.utc_now())

     

       130
       130
       +
                   }

     

       131
       131
       +
                 }

     

       132
       132
       +
               })

     

       133
       133
       +
         """

     

       134
       134
       +
         @spec post(Client.client(), String.t() | struct(), keyword()) ::

     

       135
       135
       +
                 {:ok, Req.Response.t(), Client.client()}

     

       136
       136
       +
                 | {:error, any(), Client.client()}

     

       137
       137
       +
         def post(client, name, opts \\ [])

     

       138
       138
       +
       

     

       139
       139
       +
         def post(client, name, opts) when is_binary(name) do

     

       140
       140
       +
           client.__struct__.post(client, name, opts)

     

       141
       141
       +
         end

     

       142
       142
       +
       

     

       143
       143
       +
         def post(client, %{__struct__: module} = procedure, opts) do

     

       144
       144
       +
           opts =

     

       145
       145
       +
             opts

     

       146
       146
       +
             |> then(

     

       147
       147
       +
               &if Map.get(procedure, :params), do: Keyword.put(&1, :params, procedure.params), else: &1

     

       148
       148
       +
             )

     

       149
       149
       +
             |> then(

     

       150
       150
       +
               &cond do

     

       151
       151
       +
                 Map.get(procedure, :input) -> Keyword.put(&1, :json, procedure.input)

     

       152
       152
       +
                 Map.get(procedure, :raw_input) -> Keyword.put(&1, :body, procedure.raw_input)

     

       153
       153
       +
                 true -> &1

     

       154
       154
       +
               end

     

       155
       155
       +
             )

     

       156
       156
       +
       

     

       157
       157
       +
           output_struct = Module.concat(module, Output)

     

       158
       158
       +
           output_exists = Code.ensure_loaded?(output_struct)

     

       159
       159
       +
       

     

       160
       160
       +
           case client.__struct__.post(client, module.id(), opts) do

     

       161
       161
       +
             {:ok, %{status: 200} = response, client} ->

     

       162
       162
       +
               if output_exists do

     

       163
       163
       +
                 case output_struct.from_json(response.body) do

     

       164
       164
       +
                   {:ok, output} ->

     

       165
       165
       +
                     {:ok, %{response | body: output}, client}

     

       166
       166
       +
       

     

       167
       167
       +
                   err ->

     

       168
       168
       +
                     err

     

       169
       169
       +
                 end

     

       170
       170
       +
               else

     

       171
       171
       +
                 {:ok, response, client}

     

       172
       172
       +
               end

     

       173
       173
       +
       

     

       174
       174
       +
             {:ok, _, _} = ok ->

     

       175
       175
       +
               ok

     

       176
       176
       +
       

     

       177
       177
       +
             err ->

     

       178
       178
       +
               err

     

       179
       179
       +
           end

     

       180
       180
       +
         end

     

       181
       181
       +
       

     

       182
       182
       +
         @doc """

     

       183
       183
       +
         Like `get/3` but is unauthenticated by default.

     

       184
       184
       +
         """

     

       185
       185
       +
         @spec unauthed_get(String.t(), String.t(), keyword()) ::

     

       186
       186
       +
                 {:ok, Req.Response.t()} | {:error, any()}

     

       187
       187
       +
         def unauthed_get(endpoint, name, opts \\ []) do

     

       188
       188
       +
           Req.get(url(endpoint, name), opts)

     

       189
       189
       +
         end

     

       190
       190
       +
       

     

       191
       191
       +
         @doc """

     

       192
       192
       +
         Like `post/3` but is unauthenticated by default.

     

       193
       193
       +
         """

     

       194
       194
       +
         @spec unauthed_post(String.t(), String.t(), keyword()) ::

     

       195
       195
       +
                 {:ok, Req.Response.t()} | {:error, any()}

     

       196
       196
       +
         def unauthed_post(endpoint, name, opts \\ []) do

     

       197
       197
       +
           Req.post(url(endpoint, name), opts)

     

       198
       198
       +
         end

     

       199
       199
       +
       

     

       200
       200
       +
         @doc """

     

       201
       201
       +
         Create an XRPC url based on an endpoint and a resource name.

     

       202
       202
       +
       

     

       203
       203
       +
         ## Example

     

       204
       204
       +
       

     

       205
       205
       +
             iex> Atex.XRPC.url("https://bsky.app", "app.bsky.actor.getProfile")

     

       206
       206
       +
             "https://bsky.app/xrpc/app.bsky.actor.getProfile"

     

       207
       207
       +
         """

     

       208
       208
       +
         @spec url(String.t(), String.t()) :: String.t()

     

       209
       209
       +
         def url(endpoint, resource) when is_binary(endpoint), do: "#{endpoint}/xrpc/#{resource}"

     

       210
       210
       +
       end

-2

lib/atex.ex

···

       1
       1
       -
       defmodule Atex do

     

       2
       2
       -
       end

+73

lib/atproto/com/atproto/admin/defs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.Defs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "accountView" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "deactivatedAt" => %{"format" => "datetime", "type" => "string"},

     

       9
       9
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       10
       10
       +
                 "email" => %{"type" => "string"},

     

       11
       11
       +
                 "emailConfirmedAt" => %{"format" => "datetime", "type" => "string"},

     

       12
       12
       +
                 "handle" => %{"format" => "handle", "type" => "string"},

     

       13
       13
       +
                 "indexedAt" => %{"format" => "datetime", "type" => "string"},

     

       14
       14
       +
                 "inviteNote" => %{"type" => "string"},

     

       15
       15
       +
                 "invitedBy" => %{

     

       16
       16
       +
                   "ref" => "com.atproto.server.defs#inviteCode",

     

       17
       17
       +
                   "type" => "ref"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 "invites" => %{

     

       20
       20
       +
                   "items" => %{

     

       21
       21
       +
                     "ref" => "com.atproto.server.defs#inviteCode",

     

       22
       22
       +
                     "type" => "ref"

     

       23
       23
       +
                   },

     

       24
       24
       +
                   "type" => "array"

     

       25
       25
       +
                 },

     

       26
       26
       +
                 "invitesDisabled" => %{"type" => "boolean"},

     

       27
       27
       +
                 "relatedRecords" => %{

     

       28
       28
       +
                   "items" => %{"type" => "unknown"},

     

       29
       29
       +
                   "type" => "array"

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "threatSignatures" => %{

     

       32
       32
       +
                   "items" => %{"ref" => "#threatSignature", "type" => "ref"},

     

       33
       33
       +
                   "type" => "array"

     

       34
       34
       +
                 }

     

       35
       35
       +
               },

     

       36
       36
       +
               "required" => ["did", "handle", "indexedAt"],

     

       37
       37
       +
               "type" => "object"

     

       38
       38
       +
             },

     

       39
       39
       +
             "repoBlobRef" => %{

     

       40
       40
       +
               "properties" => %{

     

       41
       41
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       42
       42
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       43
       43
       +
                 "recordUri" => %{"format" => "at-uri", "type" => "string"}

     

       44
       44
       +
               },

     

       45
       45
       +
               "required" => ["did", "cid"],

     

       46
       46
       +
               "type" => "object"

     

       47
       47
       +
             },

     

       48
       48
       +
             "repoRef" => %{

     

       49
       49
       +
               "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       50
       50
       +
               "required" => ["did"],

     

       51
       51
       +
               "type" => "object"

     

       52
       52
       +
             },

     

       53
       53
       +
             "statusAttr" => %{

     

       54
       54
       +
               "properties" => %{

     

       55
       55
       +
                 "applied" => %{"type" => "boolean"},

     

       56
       56
       +
                 "ref" => %{"type" => "string"}

     

       57
       57
       +
               },

     

       58
       58
       +
               "required" => ["applied"],

     

       59
       59
       +
               "type" => "object"

     

       60
       60
       +
             },

     

       61
       61
       +
             "threatSignature" => %{

     

       62
       62
       +
               "properties" => %{

     

       63
       63
       +
                 "property" => %{"type" => "string"},

     

       64
       64
       +
                 "value" => %{"type" => "string"}

     

       65
       65
       +
               },

     

       66
       66
       +
               "required" => ["property", "value"],

     

       67
       67
       +
               "type" => "object"

     

       68
       68
       +
             }

     

       69
       69
       +
           },

     

       70
       70
       +
           "id" => "com.atproto.admin.defs",

     

       71
       71
       +
           "lexicon" => 1

     

       72
       72
       +
         })

     

       73
       73
       +
       end

+22

lib/atproto/com/atproto/admin/deleteAccount.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.DeleteAccount do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Delete a user account as an administrator.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       12
       12
       +
                   "required" => ["did"],

     

       13
       13
       +
                   "type" => "object"

     

       14
       14
       +
                 }

     

       15
       15
       +
               },

     

       16
       16
       +
               "type" => "procedure"

     

       17
       17
       +
             }

     

       18
       18
       +
           },

     

       19
       19
       +
           "id" => "com.atproto.admin.deleteAccount",

     

       20
       20
       +
           "lexicon" => 1

     

       21
       21
       +
         })

     

       22
       22
       +
       end

+29

lib/atproto/com/atproto/admin/disableAccountInvites.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.DisableAccountInvites do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Disable an account from receiving new invite codes, but does not invalidate existing codes.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "account" => %{"format" => "did", "type" => "string"},

     

       14
       14
       +
                     "note" => %{

     

       15
       15
       +
                       "description" => "Optional reason for disabled invites.",

     

       16
       16
       +
                       "type" => "string"

     

       17
       17
       +
                     }

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["account"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "type" => "procedure"

     

       24
       24
       +
             }

     

       25
       25
       +
           },

     

       26
       26
       +
           "id" => "com.atproto.admin.disableAccountInvites",

     

       27
       27
       +
           "lexicon" => 1

     

       28
       28
       +
         })

     

       29
       29
       +
       end

+25

lib/atproto/com/atproto/admin/disableInviteCodes.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.DisableInviteCodes do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Disable some set of codes and/or all codes associated with a set of users.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "accounts" => %{"items" => %{"type" => "string"}, "type" => "array"},

     

       14
       14
       +
                     "codes" => %{"items" => %{"type" => "string"}, "type" => "array"}

     

       15
       15
       +
                   },

     

       16
       16
       +
                   "type" => "object"

     

       17
       17
       +
                 }

     

       18
       18
       +
               },

     

       19
       19
       +
               "type" => "procedure"

     

       20
       20
       +
             }

     

       21
       21
       +
           },

     

       22
       22
       +
           "id" => "com.atproto.admin.disableInviteCodes",

     

       23
       23
       +
           "lexicon" => 1

     

       24
       24
       +
         })

     

       25
       25
       +
       end

+28

lib/atproto/com/atproto/admin/enableAccountInvites.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.EnableAccountInvites do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Re-enable an account's ability to receive invite codes.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "account" => %{"format" => "did", "type" => "string"},

     

       13
       13
       +
                     "note" => %{

     

       14
       14
       +
                       "description" => "Optional reason for enabled invites.",

     

       15
       15
       +
                       "type" => "string"

     

       16
       16
       +
                     }

     

       17
       17
       +
                   },

     

       18
       18
       +
                   "required" => ["account"],

     

       19
       19
       +
                   "type" => "object"

     

       20
       20
       +
                 }

     

       21
       21
       +
               },

     

       22
       22
       +
               "type" => "procedure"

     

       23
       23
       +
             }

     

       24
       24
       +
           },

     

       25
       25
       +
           "id" => "com.atproto.admin.enableAccountInvites",

     

       26
       26
       +
           "lexicon" => 1

     

       27
       27
       +
         })

     

       28
       28
       +
       end

+26

lib/atproto/com/atproto/admin/getAccountInfo.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.GetAccountInfo do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Get details about an account.",

     

       8
       8
       +
               "output" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "ref" => "com.atproto.admin.defs#accountView",

     

       12
       12
       +
                   "type" => "ref"

     

       13
       13
       +
                 }

     

       14
       14
       +
               },

     

       15
       15
       +
               "parameters" => %{

     

       16
       16
       +
                 "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       17
       17
       +
                 "required" => ["did"],

     

       18
       18
       +
                 "type" => "params"

     

       19
       19
       +
               },

     

       20
       20
       +
               "type" => "query"

     

       21
       21
       +
             }

     

       22
       22
       +
           },

     

       23
       23
       +
           "id" => "com.atproto.admin.getAccountInfo",

     

       24
       24
       +
           "lexicon" => 1

     

       25
       25
       +
         })

     

       26
       26
       +
       end

+40

lib/atproto/com/atproto/admin/getAccountInfos.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.GetAccountInfos do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Get details about some accounts.",

     

       8
       8
       +
               "output" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "infos" => %{

     

       13
       13
       +
                       "items" => %{

     

       14
       14
       +
                         "ref" => "com.atproto.admin.defs#accountView",

     

       15
       15
       +
                         "type" => "ref"

     

       16
       16
       +
                       },

     

       17
       17
       +
                       "type" => "array"

     

       18
       18
       +
                     }

     

       19
       19
       +
                   },

     

       20
       20
       +
                   "required" => ["infos"],

     

       21
       21
       +
                   "type" => "object"

     

       22
       22
       +
                 }

     

       23
       23
       +
               },

     

       24
       24
       +
               "parameters" => %{

     

       25
       25
       +
                 "properties" => %{

     

       26
       26
       +
                   "dids" => %{

     

       27
       27
       +
                     "items" => %{"format" => "did", "type" => "string"},

     

       28
       28
       +
                     "type" => "array"

     

       29
       29
       +
                   }

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "required" => ["dids"],

     

       32
       32
       +
                 "type" => "params"

     

       33
       33
       +
               },

     

       34
       34
       +
               "type" => "query"

     

       35
       35
       +
             }

     

       36
       36
       +
           },

     

       37
       37
       +
           "id" => "com.atproto.admin.getAccountInfos",

     

       38
       38
       +
           "lexicon" => 1

     

       39
       39
       +
         })

     

       40
       40
       +
       end

+48

lib/atproto/com/atproto/admin/getInviteCodes.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.GetInviteCodes do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Get an admin view of invite codes.",

     

       8
       8
       +
               "output" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "codes" => %{

     

       13
       13
       +
                       "items" => %{

     

       14
       14
       +
                         "ref" => "com.atproto.server.defs#inviteCode",

     

       15
       15
       +
                         "type" => "ref"

     

       16
       16
       +
                       },

     

       17
       17
       +
                       "type" => "array"

     

       18
       18
       +
                     },

     

       19
       19
       +
                     "cursor" => %{"type" => "string"}

     

       20
       20
       +
                   },

     

       21
       21
       +
                   "required" => ["codes"],

     

       22
       22
       +
                   "type" => "object"

     

       23
       23
       +
                 }

     

       24
       24
       +
               },

     

       25
       25
       +
               "parameters" => %{

     

       26
       26
       +
                 "properties" => %{

     

       27
       27
       +
                   "cursor" => %{"type" => "string"},

     

       28
       28
       +
                   "limit" => %{

     

       29
       29
       +
                     "default" => 100,

     

       30
       30
       +
                     "maximum" => 500,

     

       31
       31
       +
                     "minimum" => 1,

     

       32
       32
       +
                     "type" => "integer"

     

       33
       33
       +
                   },

     

       34
       34
       +
                   "sort" => %{

     

       35
       35
       +
                     "default" => "recent",

     

       36
       36
       +
                     "knownValues" => ["recent", "usage"],

     

       37
       37
       +
                     "type" => "string"

     

       38
       38
       +
                   }

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "type" => "params"

     

       41
       41
       +
               },

     

       42
       42
       +
               "type" => "query"

     

       43
       43
       +
             }

     

       44
       44
       +
           },

     

       45
       45
       +
           "id" => "com.atproto.admin.getInviteCodes",

     

       46
       46
       +
           "lexicon" => 1

     

       47
       47
       +
         })

     

       48
       48
       +
       end

+48

lib/atproto/com/atproto/admin/getSubjectStatus.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.GetSubjectStatus do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get the service-specific admin status of a subject (account, record, or blob).",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "deactivated" => %{

     

       14
       14
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       15
       15
       +
                       "type" => "ref"

     

       16
       16
       +
                     },

     

       17
       17
       +
                     "subject" => %{

     

       18
       18
       +
                       "refs" => [

     

       19
       19
       +
                         "com.atproto.admin.defs#repoRef",

     

       20
       20
       +
                         "com.atproto.repo.strongRef",

     

       21
       21
       +
                         "com.atproto.admin.defs#repoBlobRef"

     

       22
       22
       +
                       ],

     

       23
       23
       +
                       "type" => "union"

     

       24
       24
       +
                     },

     

       25
       25
       +
                     "takedown" => %{

     

       26
       26
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       27
       27
       +
                       "type" => "ref"

     

       28
       28
       +
                     }

     

       29
       29
       +
                   },

     

       30
       30
       +
                   "required" => ["subject"],

     

       31
       31
       +
                   "type" => "object"

     

       32
       32
       +
                 }

     

       33
       33
       +
               },

     

       34
       34
       +
               "parameters" => %{

     

       35
       35
       +
                 "properties" => %{

     

       36
       36
       +
                   "blob" => %{"format" => "cid", "type" => "string"},

     

       37
       37
       +
                   "did" => %{"format" => "did", "type" => "string"},

     

       38
       38
       +
                   "uri" => %{"format" => "at-uri", "type" => "string"}

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "type" => "params"

     

       41
       41
       +
               },

     

       42
       42
       +
               "type" => "query"

     

       43
       43
       +
             }

     

       44
       44
       +
           },

     

       45
       45
       +
           "id" => "com.atproto.admin.getSubjectStatus",

     

       46
       46
       +
           "lexicon" => 1

     

       47
       47
       +
         })

     

       48
       48
       +
       end

+44

lib/atproto/com/atproto/admin/searchAccounts.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.SearchAccounts do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Get list of accounts that matches your search query.",

     

       8
       8
       +
               "output" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "accounts" => %{

     

       13
       13
       +
                       "items" => %{

     

       14
       14
       +
                         "ref" => "com.atproto.admin.defs#accountView",

     

       15
       15
       +
                         "type" => "ref"

     

       16
       16
       +
                       },

     

       17
       17
       +
                       "type" => "array"

     

       18
       18
       +
                     },

     

       19
       19
       +
                     "cursor" => %{"type" => "string"}

     

       20
       20
       +
                   },

     

       21
       21
       +
                   "required" => ["accounts"],

     

       22
       22
       +
                   "type" => "object"

     

       23
       23
       +
                 }

     

       24
       24
       +
               },

     

       25
       25
       +
               "parameters" => %{

     

       26
       26
       +
                 "properties" => %{

     

       27
       27
       +
                   "cursor" => %{"type" => "string"},

     

       28
       28
       +
                   "email" => %{"type" => "string"},

     

       29
       29
       +
                   "limit" => %{

     

       30
       30
       +
                     "default" => 50,

     

       31
       31
       +
                     "maximum" => 100,

     

       32
       32
       +
                     "minimum" => 1,

     

       33
       33
       +
                     "type" => "integer"

     

       34
       34
       +
                   }

     

       35
       35
       +
                 },

     

       36
       36
       +
                 "type" => "params"

     

       37
       37
       +
               },

     

       38
       38
       +
               "type" => "query"

     

       39
       39
       +
             }

     

       40
       40
       +
           },

     

       41
       41
       +
           "id" => "com.atproto.admin.searchAccounts",

     

       42
       42
       +
           "lexicon" => 1

     

       43
       43
       +
         })

     

       44
       44
       +
       end

+40

lib/atproto/com/atproto/admin/sendEmail.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.SendEmail do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Send email to a user's account email address.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "comment" => %{

     

       13
       13
       +
                       "description" =>

     

       14
       14
       +
                         "Additional comment by the sender that won't be used in the email itself but helpful to provide more context for moderators/reviewers",

     

       15
       15
       +
                       "type" => "string"

     

       16
       16
       +
                     },

     

       17
       17
       +
                     "content" => %{"type" => "string"},

     

       18
       18
       +
                     "recipientDid" => %{"format" => "did", "type" => "string"},

     

       19
       19
       +
                     "senderDid" => %{"format" => "did", "type" => "string"},

     

       20
       20
       +
                     "subject" => %{"type" => "string"}

     

       21
       21
       +
                   },

     

       22
       22
       +
                   "required" => ["recipientDid", "content", "senderDid"],

     

       23
       23
       +
                   "type" => "object"

     

       24
       24
       +
                 }

     

       25
       25
       +
               },

     

       26
       26
       +
               "output" => %{

     

       27
       27
       +
                 "encoding" => "application/json",

     

       28
       28
       +
                 "schema" => %{

     

       29
       29
       +
                   "properties" => %{"sent" => %{"type" => "boolean"}},

     

       30
       30
       +
                   "required" => ["sent"],

     

       31
       31
       +
                   "type" => "object"

     

       32
       32
       +
                 }

     

       33
       33
       +
               },

     

       34
       34
       +
               "type" => "procedure"

     

       35
       35
       +
             }

     

       36
       36
       +
           },

     

       37
       37
       +
           "id" => "com.atproto.admin.sendEmail",

     

       38
       38
       +
           "lexicon" => 1

     

       39
       39
       +
         })

     

       40
       40
       +
       end

+29

lib/atproto/com/atproto/admin/updateAccountEmail.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountEmail do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Administrative action to update an account's email.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "account" => %{

     

       13
       13
       +
                       "description" => "The handle or DID of the repo.",

     

       14
       14
       +
                       "format" => "at-identifier",

     

       15
       15
       +
                       "type" => "string"

     

       16
       16
       +
                     },

     

       17
       17
       +
                     "email" => %{"type" => "string"}

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["account", "email"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "type" => "procedure"

     

       24
       24
       +
             }

     

       25
       25
       +
           },

     

       26
       26
       +
           "id" => "com.atproto.admin.updateAccountEmail",

     

       27
       27
       +
           "lexicon" => 1

     

       28
       28
       +
         })

     

       29
       29
       +
       end

+25

lib/atproto/com/atproto/admin/updateAccountHandle.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountHandle do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Administrative action to update an account's handle.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       13
       13
       +
                     "handle" => %{"format" => "handle", "type" => "string"}

     

       14
       14
       +
                   },

     

       15
       15
       +
                   "required" => ["did", "handle"],

     

       16
       16
       +
                   "type" => "object"

     

       17
       17
       +
                 }

     

       18
       18
       +
               },

     

       19
       19
       +
               "type" => "procedure"

     

       20
       20
       +
             }

     

       21
       21
       +
           },

     

       22
       22
       +
           "id" => "com.atproto.admin.updateAccountHandle",

     

       23
       23
       +
           "lexicon" => 1

     

       24
       24
       +
         })

     

       25
       25
       +
       end

+25

lib/atproto/com/atproto/admin/updateAccountPassword.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountPassword do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Update the password for a user account as an administrator.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       13
       13
       +
                     "password" => %{"type" => "string"}

     

       14
       14
       +
                   },

     

       15
       15
       +
                   "required" => ["did", "password"],

     

       16
       16
       +
                   "type" => "object"

     

       17
       17
       +
                 }

     

       18
       18
       +
               },

     

       19
       19
       +
               "type" => "procedure"

     

       20
       20
       +
             }

     

       21
       21
       +
           },

     

       22
       22
       +
           "id" => "com.atproto.admin.updateAccountPassword",

     

       23
       23
       +
           "lexicon" => 1

     

       24
       24
       +
         })

     

       25
       25
       +
       end

+30

lib/atproto/com/atproto/admin/updateAccountSigningKey.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.UpdateAccountSigningKey do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Administrative action to update an account's signing key in their Did document.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       14
       14
       +
                     "signingKey" => %{

     

       15
       15
       +
                       "description" => "Did-key formatted public key",

     

       16
       16
       +
                       "format" => "did",

     

       17
       17
       +
                       "type" => "string"

     

       18
       18
       +
                     }

     

       19
       19
       +
                   },

     

       20
       20
       +
                   "required" => ["did", "signingKey"],

     

       21
       21
       +
                   "type" => "object"

     

       22
       22
       +
                 }

     

       23
       23
       +
               },

     

       24
       24
       +
               "type" => "procedure"

     

       25
       25
       +
             }

     

       26
       26
       +
           },

     

       27
       27
       +
           "id" => "com.atproto.admin.updateAccountSigningKey",

     

       28
       28
       +
           "lexicon" => 1

     

       29
       29
       +
         })

     

       30
       30
       +
       end

+61

lib/atproto/com/atproto/admin/updateSubjectStatus.ex

···

       1
       1
       +
       defmodule Com.Atproto.Admin.UpdateSubjectStatus do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Update the service-specific admin status of a subject (account, record, or blob).",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "deactivated" => %{

     

       14
       14
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       15
       15
       +
                       "type" => "ref"

     

       16
       16
       +
                     },

     

       17
       17
       +
                     "subject" => %{

     

       18
       18
       +
                       "refs" => [

     

       19
       19
       +
                         "com.atproto.admin.defs#repoRef",

     

       20
       20
       +
                         "com.atproto.repo.strongRef",

     

       21
       21
       +
                         "com.atproto.admin.defs#repoBlobRef"

     

       22
       22
       +
                       ],

     

       23
       23
       +
                       "type" => "union"

     

       24
       24
       +
                     },

     

       25
       25
       +
                     "takedown" => %{

     

       26
       26
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       27
       27
       +
                       "type" => "ref"

     

       28
       28
       +
                     }

     

       29
       29
       +
                   },

     

       30
       30
       +
                   "required" => ["subject"],

     

       31
       31
       +
                   "type" => "object"

     

       32
       32
       +
                 }

     

       33
       33
       +
               },

     

       34
       34
       +
               "output" => %{

     

       35
       35
       +
                 "encoding" => "application/json",

     

       36
       36
       +
                 "schema" => %{

     

       37
       37
       +
                   "properties" => %{

     

       38
       38
       +
                     "subject" => %{

     

       39
       39
       +
                       "refs" => [

     

       40
       40
       +
                         "com.atproto.admin.defs#repoRef",

     

       41
       41
       +
                         "com.atproto.repo.strongRef",

     

       42
       42
       +
                         "com.atproto.admin.defs#repoBlobRef"

     

       43
       43
       +
                       ],

     

       44
       44
       +
                       "type" => "union"

     

       45
       45
       +
                     },

     

       46
       46
       +
                     "takedown" => %{

     

       47
       47
       +
                       "ref" => "com.atproto.admin.defs#statusAttr",

     

       48
       48
       +
                       "type" => "ref"

     

       49
       49
       +
                     }

     

       50
       50
       +
                   },

     

       51
       51
       +
                   "required" => ["subject"],

     

       52
       52
       +
                   "type" => "object"

     

       53
       53
       +
                 }

     

       54
       54
       +
               },

     

       55
       55
       +
               "type" => "procedure"

     

       56
       56
       +
             }

     

       57
       57
       +
           },

     

       58
       58
       +
           "id" => "com.atproto.admin.updateSubjectStatus",

     

       59
       59
       +
           "lexicon" => 1

     

       60
       60
       +
         })

     

       61
       61
       +
       end

+27

lib/atproto/com/atproto/identity/defs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.Defs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "identityInfo" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       9
       9
       +
                 "didDoc" => %{

     

       10
       10
       +
                   "description" => "The complete DID document for the identity.",

     

       11
       11
       +
                   "type" => "unknown"

     

       12
       12
       +
                 },

     

       13
       13
       +
                 "handle" => %{

     

       14
       14
       +
                   "description" =>

     

       15
       15
       +
                     "The validated handle of the account; or 'handle.invalid' if the handle did not bi-directionally match the DID document.",

     

       16
       16
       +
                   "format" => "handle",

     

       17
       17
       +
                   "type" => "string"

     

       18
       18
       +
                 }

     

       19
       19
       +
               },

     

       20
       20
       +
               "required" => ["did", "handle", "didDoc"],

     

       21
       21
       +
               "type" => "object"

     

       22
       22
       +
             }

     

       23
       23
       +
           },

     

       24
       24
       +
           "id" => "com.atproto.identity.defs",

     

       25
       25
       +
           "lexicon" => 1

     

       26
       26
       +
         })

     

       27
       27
       +
       end

+35

lib/atproto/com/atproto/identity/getRecommendedDidCredentials.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.GetRecommendedDidCredentials do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Describe the credentials that should be included in the DID doc of an account that is migrating to this service.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "alsoKnownAs" => %{

     

       14
       14
       +
                       "items" => %{"type" => "string"},

     

       15
       15
       +
                       "type" => "array"

     

       16
       16
       +
                     },

     

       17
       17
       +
                     "rotationKeys" => %{

     

       18
       18
       +
                       "description" =>

     

       19
       19
       +
                         "Recommended rotation keys for PLC dids. Should be undefined (or ignored) for did:webs.",

     

       20
       20
       +
                       "items" => %{"type" => "string"},

     

       21
       21
       +
                       "type" => "array"

     

       22
       22
       +
                     },

     

       23
       23
       +
                     "services" => %{"type" => "unknown"},

     

       24
       24
       +
                     "verificationMethods" => %{"type" => "unknown"}

     

       25
       25
       +
                   },

     

       26
       26
       +
                   "type" => "object"

     

       27
       27
       +
                 }

     

       28
       28
       +
               },

     

       29
       29
       +
               "type" => "query"

     

       30
       30
       +
             }

     

       31
       31
       +
           },

     

       32
       32
       +
           "id" => "com.atproto.identity.getRecommendedDidCredentials",

     

       33
       33
       +
           "lexicon" => 1

     

       34
       34
       +
         })

     

       35
       35
       +
       end

+47

lib/atproto/com/atproto/identity/refreshIdentity.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.RefreshIdentity do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Request that the server re-resolve an identity (DID and handle). The server may ignore this request, or require authentication, depending on the role, implementation, and policy of the server.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{

     

       11
       11
       +
                   "description" =>

     

       12
       12
       +
                     "The resolution process confirmed that the handle does not resolve to any DID.",

     

       13
       13
       +
                   "name" => "HandleNotFound"

     

       14
       14
       +
                 },

     

       15
       15
       +
                 %{

     

       16
       16
       +
                   "description" => "The DID resolution process confirmed that there is no current DID.",

     

       17
       17
       +
                   "name" => "DidNotFound"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 %{

     

       20
       20
       +
                   "description" => "The DID previously existed, but has been deactivated.",

     

       21
       21
       +
                   "name" => "DidDeactivated"

     

       22
       22
       +
                 }

     

       23
       23
       +
               ],

     

       24
       24
       +
               "input" => %{

     

       25
       25
       +
                 "encoding" => "application/json",

     

       26
       26
       +
                 "schema" => %{

     

       27
       27
       +
                   "properties" => %{

     

       28
       28
       +
                     "identifier" => %{"format" => "at-identifier", "type" => "string"}

     

       29
       29
       +
                   },

     

       30
       30
       +
                   "required" => ["identifier"],

     

       31
       31
       +
                   "type" => "object"

     

       32
       32
       +
                 }

     

       33
       33
       +
               },

     

       34
       34
       +
               "output" => %{

     

       35
       35
       +
                 "encoding" => "application/json",

     

       36
       36
       +
                 "schema" => %{

     

       37
       37
       +
                   "ref" => "com.atproto.identity.defs#identityInfo",

     

       38
       38
       +
                   "type" => "ref"

     

       39
       39
       +
                 }

     

       40
       40
       +
               },

     

       41
       41
       +
               "type" => "procedure"

     

       42
       42
       +
             }

     

       43
       43
       +
           },

     

       44
       44
       +
           "id" => "com.atproto.identity.refreshIdentity",

     

       45
       45
       +
           "lexicon" => 1

     

       46
       46
       +
         })

     

       47
       47
       +
       end

+15

lib/atproto/com/atproto/identity/requestPlcOperationSignature.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.RequestPlcOperationSignature do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Request an email with a code to in order to request a signed PLC operation. Requires Auth.",

     

       9
       9
       +
               "type" => "procedure"

     

       10
       10
       +
             }

     

       11
       11
       +
           },

     

       12
       12
       +
           "id" => "com.atproto.identity.requestPlcOperationSignature",

     

       13
       13
       +
           "lexicon" => 1

     

       14
       14
       +
         })

     

       15
       15
       +
       end

+48

lib/atproto/com/atproto/identity/resolveDid.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.ResolveDid do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Resolves DID to DID document. Does not bi-directionally verify handle.",

     

       8
       8
       +
               "errors" => [

     

       9
       9
       +
                 %{

     

       10
       10
       +
                   "description" => "The DID resolution process confirmed that there is no current DID.",

     

       11
       11
       +
                   "name" => "DidNotFound"

     

       12
       12
       +
                 },

     

       13
       13
       +
                 %{

     

       14
       14
       +
                   "description" => "The DID previously existed, but has been deactivated.",

     

       15
       15
       +
                   "name" => "DidDeactivated"

     

       16
       16
       +
                 }

     

       17
       17
       +
               ],

     

       18
       18
       +
               "output" => %{

     

       19
       19
       +
                 "encoding" => "application/json",

     

       20
       20
       +
                 "schema" => %{

     

       21
       21
       +
                   "properties" => %{

     

       22
       22
       +
                     "didDoc" => %{

     

       23
       23
       +
                       "description" => "The complete DID document for the identity.",

     

       24
       24
       +
                       "type" => "unknown"

     

       25
       25
       +
                     }

     

       26
       26
       +
                   },

     

       27
       27
       +
                   "required" => ["didDoc"],

     

       28
       28
       +
                   "type" => "object"

     

       29
       29
       +
                 }

     

       30
       30
       +
               },

     

       31
       31
       +
               "parameters" => %{

     

       32
       32
       +
                 "properties" => %{

     

       33
       33
       +
                   "did" => %{

     

       34
       34
       +
                     "description" => "DID to resolve.",

     

       35
       35
       +
                     "format" => "did",

     

       36
       36
       +
                     "type" => "string"

     

       37
       37
       +
                   }

     

       38
       38
       +
                 },

     

       39
       39
       +
                 "required" => ["did"],

     

       40
       40
       +
                 "type" => "params"

     

       41
       41
       +
               },

     

       42
       42
       +
               "type" => "query"

     

       43
       43
       +
             }

     

       44
       44
       +
           },

     

       45
       45
       +
           "id" => "com.atproto.identity.resolveDid",

     

       46
       46
       +
           "lexicon" => 1

     

       47
       47
       +
         })

     

       48
       48
       +
       end

+41

lib/atproto/com/atproto/identity/resolveHandle.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.ResolveHandle do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Resolves an atproto handle (hostname) to a DID. Does not necessarily bi-directionally verify against the the DID document.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{

     

       11
       11
       +
                   "description" =>

     

       12
       12
       +
                     "The resolution process confirmed that the handle does not resolve to any DID.",

     

       13
       13
       +
                   "name" => "HandleNotFound"

     

       14
       14
       +
                 }

     

       15
       15
       +
               ],

     

       16
       16
       +
               "output" => %{

     

       17
       17
       +
                 "encoding" => "application/json",

     

       18
       18
       +
                 "schema" => %{

     

       19
       19
       +
                   "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       20
       20
       +
                   "required" => ["did"],

     

       21
       21
       +
                   "type" => "object"

     

       22
       22
       +
                 }

     

       23
       23
       +
               },

     

       24
       24
       +
               "parameters" => %{

     

       25
       25
       +
                 "properties" => %{

     

       26
       26
       +
                   "handle" => %{

     

       27
       27
       +
                     "description" => "The handle to resolve.",

     

       28
       28
       +
                     "format" => "handle",

     

       29
       29
       +
                     "type" => "string"

     

       30
       30
       +
                   }

     

       31
       31
       +
                 },

     

       32
       32
       +
                 "required" => ["handle"],

     

       33
       33
       +
                 "type" => "params"

     

       34
       34
       +
               },

     

       35
       35
       +
               "type" => "query"

     

       36
       36
       +
             }

     

       37
       37
       +
           },

     

       38
       38
       +
           "id" => "com.atproto.identity.resolveHandle",

     

       39
       39
       +
           "lexicon" => 1

     

       40
       40
       +
         })

     

       41
       41
       +
       end

+48

lib/atproto/com/atproto/identity/resolveIdentity.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.ResolveIdentity do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Resolves an identity (DID or Handle) to a full identity (DID document and verified handle).",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{

     

       11
       11
       +
                   "description" =>

     

       12
       12
       +
                     "The resolution process confirmed that the handle does not resolve to any DID.",

     

       13
       13
       +
                   "name" => "HandleNotFound"

     

       14
       14
       +
                 },

     

       15
       15
       +
                 %{

     

       16
       16
       +
                   "description" => "The DID resolution process confirmed that there is no current DID.",

     

       17
       17
       +
                   "name" => "DidNotFound"

     

       18
       18
       +
                 },

     

       19
       19
       +
                 %{

     

       20
       20
       +
                   "description" => "The DID previously existed, but has been deactivated.",

     

       21
       21
       +
                   "name" => "DidDeactivated"

     

       22
       22
       +
                 }

     

       23
       23
       +
               ],

     

       24
       24
       +
               "output" => %{

     

       25
       25
       +
                 "encoding" => "application/json",

     

       26
       26
       +
                 "schema" => %{

     

       27
       27
       +
                   "ref" => "com.atproto.identity.defs#identityInfo",

     

       28
       28
       +
                   "type" => "ref"

     

       29
       29
       +
                 }

     

       30
       30
       +
               },

     

       31
       31
       +
               "parameters" => %{

     

       32
       32
       +
                 "properties" => %{

     

       33
       33
       +
                   "identifier" => %{

     

       34
       34
       +
                     "description" => "Handle or DID to resolve.",

     

       35
       35
       +
                     "format" => "at-identifier",

     

       36
       36
       +
                     "type" => "string"

     

       37
       37
       +
                   }

     

       38
       38
       +
                 },

     

       39
       39
       +
                 "required" => ["identifier"],

     

       40
       40
       +
                 "type" => "params"

     

       41
       41
       +
               },

     

       42
       42
       +
               "type" => "query"

     

       43
       43
       +
             }

     

       44
       44
       +
           },

     

       45
       45
       +
           "id" => "com.atproto.identity.resolveIdentity",

     

       46
       46
       +
           "lexicon" => 1

     

       47
       47
       +
         })

     

       48
       48
       +
       end

+51

lib/atproto/com/atproto/identity/signPlcOperation.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.SignPlcOperation do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Signs a PLC operation to update some value(s) in the requesting DID's document.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "alsoKnownAs" => %{

     

       14
       14
       +
                       "items" => %{"type" => "string"},

     

       15
       15
       +
                       "type" => "array"

     

       16
       16
       +
                     },

     

       17
       17
       +
                     "rotationKeys" => %{

     

       18
       18
       +
                       "items" => %{"type" => "string"},

     

       19
       19
       +
                       "type" => "array"

     

       20
       20
       +
                     },

     

       21
       21
       +
                     "services" => %{"type" => "unknown"},

     

       22
       22
       +
                     "token" => %{

     

       23
       23
       +
                       "description" =>

     

       24
       24
       +
                         "A token received through com.atproto.identity.requestPlcOperationSignature",

     

       25
       25
       +
                       "type" => "string"

     

       26
       26
       +
                     },

     

       27
       27
       +
                     "verificationMethods" => %{"type" => "unknown"}

     

       28
       28
       +
                   },

     

       29
       29
       +
                   "type" => "object"

     

       30
       30
       +
                 }

     

       31
       31
       +
               },

     

       32
       32
       +
               "output" => %{

     

       33
       33
       +
                 "encoding" => "application/json",

     

       34
       34
       +
                 "schema" => %{

     

       35
       35
       +
                   "properties" => %{

     

       36
       36
       +
                     "operation" => %{

     

       37
       37
       +
                       "description" => "A signed DID PLC operation.",

     

       38
       38
       +
                       "type" => "unknown"

     

       39
       39
       +
                     }

     

       40
       40
       +
                   },

     

       41
       41
       +
                   "required" => ["operation"],

     

       42
       42
       +
                   "type" => "object"

     

       43
       43
       +
                 }

     

       44
       44
       +
               },

     

       45
       45
       +
               "type" => "procedure"

     

       46
       46
       +
             }

     

       47
       47
       +
           },

     

       48
       48
       +
           "id" => "com.atproto.identity.signPlcOperation",

     

       49
       49
       +
           "lexicon" => 1

     

       50
       50
       +
         })

     

       51
       51
       +
       end

+23

lib/atproto/com/atproto/identity/submitPlcOperation.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.SubmitPlcOperation do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Validates a PLC operation to ensure that it doesn't violate a service's constraints or get the identity into a bad state, then submits it to the PLC registry",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{"operation" => %{"type" => "unknown"}},

     

       13
       13
       +
                   "required" => ["operation"],

     

       14
       14
       +
                   "type" => "object"

     

       15
       15
       +
                 }

     

       16
       16
       +
               },

     

       17
       17
       +
               "type" => "procedure"

     

       18
       18
       +
             }

     

       19
       19
       +
           },

     

       20
       20
       +
           "id" => "com.atproto.identity.submitPlcOperation",

     

       21
       21
       +
           "lexicon" => 1

     

       22
       22
       +
         })

     

       23
       23
       +
       end

+29

lib/atproto/com/atproto/identity/updateHandle.ex

···

       1
       1
       +
       defmodule Com.Atproto.Identity.UpdateHandle do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Updates the current account's handle. Verifies handle validity, and updates did:plc document if necessary. Implemented by PDS, and requires auth.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "handle" => %{

     

       14
       14
       +
                       "description" => "The new handle.",

     

       15
       15
       +
                       "format" => "handle",

     

       16
       16
       +
                       "type" => "string"

     

       17
       17
       +
                     }

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["handle"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "type" => "procedure"

     

       24
       24
       +
             }

     

       25
       25
       +
           },

     

       26
       26
       +
           "id" => "com.atproto.identity.updateHandle",

     

       27
       27
       +
           "lexicon" => 1

     

       28
       28
       +
         })

     

       29
       29
       +
       end

+170

lib/atproto/com/atproto/label/defs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Label.Defs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "label" => %{

     

       7
       7
       +
               "description" => "Metadata tag on an atproto resource (eg, repo or record).",

     

       8
       8
       +
               "properties" => %{

     

       9
       9
       +
                 "cid" => %{

     

       10
       10
       +
                   "description" =>

     

       11
       11
       +
                     "Optionally, CID specifying the specific version of 'uri' resource this label applies to.",

     

       12
       12
       +
                   "format" => "cid",

     

       13
       13
       +
                   "type" => "string"

     

       14
       14
       +
                 },

     

       15
       15
       +
                 "cts" => %{

     

       16
       16
       +
                   "description" => "Timestamp when this label was created.",

     

       17
       17
       +
                   "format" => "datetime",

     

       18
       18
       +
                   "type" => "string"

     

       19
       19
       +
                 },

     

       20
       20
       +
                 "exp" => %{

     

       21
       21
       +
                   "description" => "Timestamp at which this label expires (no longer applies).",

     

       22
       22
       +
                   "format" => "datetime",

     

       23
       23
       +
                   "type" => "string"

     

       24
       24
       +
                 },

     

       25
       25
       +
                 "neg" => %{

     

       26
       26
       +
                   "description" => "If true, this is a negation label, overwriting a previous label.",

     

       27
       27
       +
                   "type" => "boolean"

     

       28
       28
       +
                 },

     

       29
       29
       +
                 "sig" => %{

     

       30
       30
       +
                   "description" => "Signature of dag-cbor encoded label.",

     

       31
       31
       +
                   "type" => "bytes"

     

       32
       32
       +
                 },

     

       33
       33
       +
                 "src" => %{

     

       34
       34
       +
                   "description" => "DID of the actor who created this label.",

     

       35
       35
       +
                   "format" => "did",

     

       36
       36
       +
                   "type" => "string"

     

       37
       37
       +
                 },

     

       38
       38
       +
                 "uri" => %{

     

       39
       39
       +
                   "description" =>

     

       40
       40
       +
                     "AT URI of the record, repository (account), or other resource that this label applies to.",

     

       41
       41
       +
                   "format" => "uri",

     

       42
       42
       +
                   "type" => "string"

     

       43
       43
       +
                 },

     

       44
       44
       +
                 "val" => %{

     

       45
       45
       +
                   "description" => "The short string name of the value or type of this label.",

     

       46
       46
       +
                   "maxLength" => 128,

     

       47
       47
       +
                   "type" => "string"

     

       48
       48
       +
                 },

     

       49
       49
       +
                 "ver" => %{

     

       50
       50
       +
                   "description" => "The AT Protocol version of the label object.",

     

       51
       51
       +
                   "type" => "integer"

     

       52
       52
       +
                 }

     

       53
       53
       +
               },

     

       54
       54
       +
               "required" => ["src", "uri", "val", "cts"],

     

       55
       55
       +
               "type" => "object"

     

       56
       56
       +
             },

     

       57
       57
       +
             "labelValue" => %{

     

       58
       58
       +
               "knownValues" => [

     

       59
       59
       +
                 "!hide",

     

       60
       60
       +
                 "!no-promote",

     

       61
       61
       +
                 "!warn",

     

       62
       62
       +
                 "!no-unauthenticated",

     

       63
       63
       +
                 "dmca-violation",

     

       64
       64
       +
                 "doxxing",

     

       65
       65
       +
                 "porn",

     

       66
       66
       +
                 "sexual",

     

       67
       67
       +
                 "nudity",

     

       68
       68
       +
                 "nsfl",

     

       69
       69
       +
                 "gore"

     

       70
       70
       +
               ],

     

       71
       71
       +
               "type" => "string"

     

       72
       72
       +
             },

     

       73
       73
       +
             "labelValueDefinition" => %{

     

       74
       74
       +
               "description" => "Declares a label value and its expected interpretations and behaviors.",

     

       75
       75
       +
               "properties" => %{

     

       76
       76
       +
                 "adultOnly" => %{

     

       77
       77
       +
                   "description" =>

     

       78
       78
       +
                     "Does the user need to have adult content enabled in order to configure this label?",

     

       79
       79
       +
                   "type" => "boolean"

     

       80
       80
       +
                 },

     

       81
       81
       +
                 "blurs" => %{

     

       82
       82
       +
                   "description" =>

     

       83
       83
       +
                     "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",

     

       84
       84
       +
                   "knownValues" => ["content", "media", "none"],

     

       85
       85
       +
                   "type" => "string"

     

       86
       86
       +
                 },

     

       87
       87
       +
                 "defaultSetting" => %{

     

       88
       88
       +
                   "default" => "warn",

     

       89
       89
       +
                   "description" => "The default setting for this label.",

     

       90
       90
       +
                   "knownValues" => ["ignore", "warn", "hide"],

     

       91
       91
       +
                   "type" => "string"

     

       92
       92
       +
                 },

     

       93
       93
       +
                 "identifier" => %{

     

       94
       94
       +
                   "description" =>

     

       95
       95
       +
                     "The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).",

     

       96
       96
       +
                   "maxGraphemes" => 100,

     

       97
       97
       +
                   "maxLength" => 100,

     

       98
       98
       +
                   "type" => "string"

     

       99
       99
       +
                 },

     

       100
       100
       +
                 "locales" => %{

     

       101
       101
       +
                   "items" => %{"ref" => "#labelValueDefinitionStrings", "type" => "ref"},

     

       102
       102
       +
                   "type" => "array"

     

       103
       103
       +
                 },

     

       104
       104
       +
                 "severity" => %{

     

       105
       105
       +
                   "description" =>

     

       106
       106
       +
                     "How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.",

     

       107
       107
       +
                   "knownValues" => ["inform", "alert", "none"],

     

       108
       108
       +
                   "type" => "string"

     

       109
       109
       +
                 }

     

       110
       110
       +
               },

     

       111
       111
       +
               "required" => ["identifier", "severity", "blurs", "locales"],

     

       112
       112
       +
               "type" => "object"

     

       113
       113
       +
             },

     

       114
       114
       +
             "labelValueDefinitionStrings" => %{

     

       115
       115
       +
               "description" =>

     

       116
       116
       +
                 "Strings which describe the label in the UI, localized into a specific language.",

     

       117
       117
       +
               "properties" => %{

     

       118
       118
       +
                 "description" => %{

     

       119
       119
       +
                   "description" =>

     

       120
       120
       +
                     "A longer description of what the label means and why it might be applied.",

     

       121
       121
       +
                   "maxGraphemes" => 10000,

     

       122
       122
       +
                   "maxLength" => 100_000,

     

       123
       123
       +
                   "type" => "string"

     

       124
       124
       +
                 },

     

       125
       125
       +
                 "lang" => %{

     

       126
       126
       +
                   "description" => "The code of the language these strings are written in.",

     

       127
       127
       +
                   "format" => "language",

     

       128
       128
       +
                   "type" => "string"

     

       129
       129
       +
                 },

     

       130
       130
       +
                 "name" => %{

     

       131
       131
       +
                   "description" => "A short human-readable name for the label.",

     

       132
       132
       +
                   "maxGraphemes" => 64,

     

       133
       133
       +
                   "maxLength" => 640,

     

       134
       134
       +
                   "type" => "string"

     

       135
       135
       +
                 }

     

       136
       136
       +
               },

     

       137
       137
       +
               "required" => ["lang", "name", "description"],

     

       138
       138
       +
               "type" => "object"

     

       139
       139
       +
             },

     

       140
       140
       +
             "selfLabel" => %{

     

       141
       141
       +
               "description" =>

     

       142
       142
       +
                 "Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.",

     

       143
       143
       +
               "properties" => %{

     

       144
       144
       +
                 "val" => %{

     

       145
       145
       +
                   "description" => "The short string name of the value or type of this label.",

     

       146
       146
       +
                   "maxLength" => 128,

     

       147
       147
       +
                   "type" => "string"

     

       148
       148
       +
                 }

     

       149
       149
       +
               },

     

       150
       150
       +
               "required" => ["val"],

     

       151
       151
       +
               "type" => "object"

     

       152
       152
       +
             },

     

       153
       153
       +
             "selfLabels" => %{

     

       154
       154
       +
               "description" =>

     

       155
       155
       +
                 "Metadata tags on an atproto record, published by the author within the record.",

     

       156
       156
       +
               "properties" => %{

     

       157
       157
       +
                 "values" => %{

     

       158
       158
       +
                   "items" => %{"ref" => "#selfLabel", "type" => "ref"},

     

       159
       159
       +
                   "maxLength" => 10,

     

       160
       160
       +
                   "type" => "array"

     

       161
       161
       +
                 }

     

       162
       162
       +
               },

     

       163
       163
       +
               "required" => ["values"],

     

       164
       164
       +
               "type" => "object"

     

       165
       165
       +
             }

     

       166
       166
       +
           },

     

       167
       167
       +
           "id" => "com.atproto.label.defs",

     

       168
       168
       +
           "lexicon" => 1

     

       169
       169
       +
         })

     

       170
       170
       +
       end

+56

lib/atproto/com/atproto/label/queryLabels.ex

···

       1
       1
       +
       defmodule Com.Atproto.Label.QueryLabels do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Find labels relevant to the provided AT-URI patterns. Public endpoint for moderation services, though may return different or additional results with auth.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       14
       +
                     "labels" => %{

     

       15
       15
       +
                       "items" => %{

     

       16
       16
       +
                         "ref" => "com.atproto.label.defs#label",

     

       17
       17
       +
                         "type" => "ref"

     

       18
       18
       +
                       },

     

       19
       19
       +
                       "type" => "array"

     

       20
       20
       +
                     }

     

       21
       21
       +
                   },

     

       22
       22
       +
                   "required" => ["labels"],

     

       23
       23
       +
                   "type" => "object"

     

       24
       24
       +
                 }

     

       25
       25
       +
               },

     

       26
       26
       +
               "parameters" => %{

     

       27
       27
       +
                 "properties" => %{

     

       28
       28
       +
                   "cursor" => %{"type" => "string"},

     

       29
       29
       +
                   "limit" => %{

     

       30
       30
       +
                     "default" => 50,

     

       31
       31
       +
                     "maximum" => 250,

     

       32
       32
       +
                     "minimum" => 1,

     

       33
       33
       +
                     "type" => "integer"

     

       34
       34
       +
                   },

     

       35
       35
       +
                   "sources" => %{

     

       36
       36
       +
                     "description" => "Optional list of label sources (DIDs) to filter on.",

     

       37
       37
       +
                     "items" => %{"format" => "did", "type" => "string"},

     

       38
       38
       +
                     "type" => "array"

     

       39
       39
       +
                   },

     

       40
       40
       +
                   "uriPatterns" => %{

     

       41
       41
       +
                     "description" =>

     

       42
       42
       +
                       "List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI.",

     

       43
       43
       +
                     "items" => %{"type" => "string"},

     

       44
       44
       +
                     "type" => "array"

     

       45
       45
       +
                   }

     

       46
       46
       +
                 },

     

       47
       47
       +
                 "required" => ["uriPatterns"],

     

       48
       48
       +
                 "type" => "params"

     

       49
       49
       +
               },

     

       50
       50
       +
               "type" => "query"

     

       51
       51
       +
             }

     

       52
       52
       +
           },

     

       53
       53
       +
           "id" => "com.atproto.label.queryLabels",

     

       54
       54
       +
           "lexicon" => 1

     

       55
       55
       +
         })

     

       56
       56
       +
       end

+47

lib/atproto/com/atproto/label/subscribeLabels.ex

···

       1
       1
       +
       defmodule Com.Atproto.Label.SubscribeLabels do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "info" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "message" => %{"type" => "string"},

     

       9
       9
       +
                 "name" => %{"knownValues" => ["OutdatedCursor"], "type" => "string"}

     

       10
       10
       +
               },

     

       11
       11
       +
               "required" => ["name"],

     

       12
       12
       +
               "type" => "object"

     

       13
       13
       +
             },

     

       14
       14
       +
             "labels" => %{

     

       15
       15
       +
               "properties" => %{

     

       16
       16
       +
                 "labels" => %{

     

       17
       17
       +
                   "items" => %{"ref" => "com.atproto.label.defs#label", "type" => "ref"},

     

       18
       18
       +
                   "type" => "array"

     

       19
       19
       +
                 },

     

       20
       20
       +
                 "seq" => %{"type" => "integer"}

     

       21
       21
       +
               },

     

       22
       22
       +
               "required" => ["seq", "labels"],

     

       23
       23
       +
               "type" => "object"

     

       24
       24
       +
             },

     

       25
       25
       +
             "main" => %{

     

       26
       26
       +
               "description" =>

     

       27
       27
       +
                 "Subscribe to stream of labels (and negations). Public endpoint implemented by mod services. Uses same sequencing scheme as repo event stream.",

     

       28
       28
       +
               "errors" => [%{"name" => "FutureCursor"}],

     

       29
       29
       +
               "message" => %{

     

       30
       30
       +
                 "schema" => %{"refs" => ["#labels", "#info"], "type" => "union"}

     

       31
       31
       +
               },

     

       32
       32
       +
               "parameters" => %{

     

       33
       33
       +
                 "properties" => %{

     

       34
       34
       +
                   "cursor" => %{

     

       35
       35
       +
                     "description" => "The last known event seq number to backfill from.",

     

       36
       36
       +
                     "type" => "integer"

     

       37
       37
       +
                   }

     

       38
       38
       +
                 },

     

       39
       39
       +
                 "type" => "params"

     

       40
       40
       +
               },

     

       41
       41
       +
               "type" => "subscription"

     

       42
       42
       +
             }

     

       43
       43
       +
           },

     

       44
       44
       +
           "id" => "com.atproto.label.subscribeLabels",

     

       45
       45
       +
           "lexicon" => 1

     

       46
       46
       +
         })

     

       47
       47
       +
       end

+27

lib/atproto/com/atproto/lexicon/schema.ex

···

       1
       1
       +
       defmodule Com.Atproto.Lexicon.Schema do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Representation of Lexicon schemas themselves, when published as atproto records. Note that the schema language is not defined in Lexicon; this meta schema currently only includes a single version field ('lexicon'). See the atproto specifications for description of the other expected top-level fields ('id', 'defs', etc).",

     

       9
       9
       +
               "key" => "nsid",

     

       10
       10
       +
               "record" => %{

     

       11
       11
       +
                 "properties" => %{

     

       12
       12
       +
                   "lexicon" => %{

     

       13
       13
       +
                     "description" =>

     

       14
       14
       +
                       "Indicates the 'version' of the Lexicon language. Must be '1' for the current atproto/Lexicon schema system.",

     

       15
       15
       +
                     "type" => "integer"

     

       16
       16
       +
                   }

     

       17
       17
       +
                 },

     

       18
       18
       +
                 "required" => ["lexicon"],

     

       19
       19
       +
                 "type" => "object"

     

       20
       20
       +
               },

     

       21
       21
       +
               "type" => "record"

     

       22
       22
       +
             }

     

       23
       23
       +
           },

     

       24
       24
       +
           "id" => "com.atproto.lexicon.schema",

     

       25
       25
       +
           "lexicon" => 1

     

       26
       26
       +
         })

     

       27
       27
       +
       end

+81

lib/atproto/com/atproto/moderation/createReport.ex

···

       1
       1
       +
       defmodule Com.Atproto.Moderation.CreateReport do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Submit a moderation report regarding an atproto account or record. Implemented by moderation services (with PDS proxying), and requires auth.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "modTool" => %{"ref" => "#modTool", "type" => "ref"},

     

       14
       14
       +
                     "reason" => %{

     

       15
       15
       +
                       "description" => "Additional context about the content and violation.",

     

       16
       16
       +
                       "maxGraphemes" => 2000,

     

       17
       17
       +
                       "maxLength" => 20000,

     

       18
       18
       +
                       "type" => "string"

     

       19
       19
       +
                     },

     

       20
       20
       +
                     "reasonType" => %{

     

       21
       21
       +
                       "description" => "Indicates the broad category of violation the report is for.",

     

       22
       22
       +
                       "ref" => "com.atproto.moderation.defs#reasonType",

     

       23
       23
       +
                       "type" => "ref"

     

       24
       24
       +
                     },

     

       25
       25
       +
                     "subject" => %{

     

       26
       26
       +
                       "refs" => ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"],

     

       27
       27
       +
                       "type" => "union"

     

       28
       28
       +
                     }

     

       29
       29
       +
                   },

     

       30
       30
       +
                   "required" => ["reasonType", "subject"],

     

       31
       31
       +
                   "type" => "object"

     

       32
       32
       +
                 }

     

       33
       33
       +
               },

     

       34
       34
       +
               "output" => %{

     

       35
       35
       +
                 "encoding" => "application/json",

     

       36
       36
       +
                 "schema" => %{

     

       37
       37
       +
                   "properties" => %{

     

       38
       38
       +
                     "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       39
       39
       +
                     "id" => %{"type" => "integer"},

     

       40
       40
       +
                     "reason" => %{

     

       41
       41
       +
                       "maxGraphemes" => 2000,

     

       42
       42
       +
                       "maxLength" => 20000,

     

       43
       43
       +
                       "type" => "string"

     

       44
       44
       +
                     },

     

       45
       45
       +
                     "reasonType" => %{

     

       46
       46
       +
                       "ref" => "com.atproto.moderation.defs#reasonType",

     

       47
       47
       +
                       "type" => "ref"

     

       48
       48
       +
                     },

     

       49
       49
       +
                     "reportedBy" => %{"format" => "did", "type" => "string"},

     

       50
       50
       +
                     "subject" => %{

     

       51
       51
       +
                       "refs" => ["com.atproto.admin.defs#repoRef", "com.atproto.repo.strongRef"],

     

       52
       52
       +
                       "type" => "union"

     

       53
       53
       +
                     }

     

       54
       54
       +
                   },

     

       55
       55
       +
                   "required" => ["id", "reasonType", "subject", "reportedBy", "createdAt"],

     

       56
       56
       +
                   "type" => "object"

     

       57
       57
       +
                 }

     

       58
       58
       +
               },

     

       59
       59
       +
               "type" => "procedure"

     

       60
       60
       +
             },

     

       61
       61
       +
             "modTool" => %{

     

       62
       62
       +
               "description" => "Moderation tool information for tracing the source of the action",

     

       63
       63
       +
               "properties" => %{

     

       64
       64
       +
                 "meta" => %{

     

       65
       65
       +
                   "description" => "Additional arbitrary metadata about the source",

     

       66
       66
       +
                   "type" => "unknown"

     

       67
       67
       +
                 },

     

       68
       68
       +
                 "name" => %{

     

       69
       69
       +
                   "description" =>

     

       70
       70
       +
                     "Name/identifier of the source (e.g., 'bsky-app/android', 'bsky-web/chrome')",

     

       71
       71
       +
                   "type" => "string"

     

       72
       72
       +
                 }

     

       73
       73
       +
               },

     

       74
       74
       +
               "required" => ["name"],

     

       75
       75
       +
               "type" => "object"

     

       76
       76
       +
             }

     

       77
       77
       +
           },

     

       78
       78
       +
           "id" => "com.atproto.moderation.createReport",

     

       79
       79
       +
           "lexicon" => 1

     

       80
       80
       +
         })

     

       81
       81
       +
       end

+101

lib/atproto/com/atproto/moderation/defs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Moderation.Defs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "reasonAppeal" => %{

     

       7
       7
       +
               "description" => "Appeal a previously taken moderation action",

     

       8
       8
       +
               "type" => "token"

     

       9
       9
       +
             },

     

       10
       10
       +
             "reasonMisleading" => %{

     

       11
       11
       +
               "description" =>

     

       12
       12
       +
                 "Misleading identity, affiliation, or content. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingOther`.",

     

       13
       13
       +
               "type" => "token"

     

       14
       14
       +
             },

     

       15
       15
       +
             "reasonOther" => %{

     

       16
       16
       +
               "description" =>

     

       17
       17
       +
                 "Reports not falling under another report category. Prefer new lexicon definition `tools.ozone.report.defs#reasonOther`.",

     

       18
       18
       +
               "type" => "token"

     

       19
       19
       +
             },

     

       20
       20
       +
             "reasonRude" => %{

     

       21
       21
       +
               "description" =>

     

       22
       22
       +
                 "Rude, harassing, explicit, or otherwise unwelcoming behavior. Prefer new lexicon definition `tools.ozone.report.defs#reasonHarassmentOther`.",

     

       23
       23
       +
               "type" => "token"

     

       24
       24
       +
             },

     

       25
       25
       +
             "reasonSexual" => %{

     

       26
       26
       +
               "description" =>

     

       27
       27
       +
                 "Unwanted or mislabeled sexual content. Prefer new lexicon definition `tools.ozone.report.defs#reasonSexualUnlabeled`.",

     

       28
       28
       +
               "type" => "token"

     

       29
       29
       +
             },

     

       30
       30
       +
             "reasonSpam" => %{

     

       31
       31
       +
               "description" =>

     

       32
       32
       +
                 "Spam: frequent unwanted promotion, replies, mentions. Prefer new lexicon definition `tools.ozone.report.defs#reasonMisleadingSpam`.",

     

       33
       33
       +
               "type" => "token"

     

       34
       34
       +
             },

     

       35
       35
       +
             "reasonType" => %{

     

       36
       36
       +
               "knownValues" => [

     

       37
       37
       +
                 "com.atproto.moderation.defs#reasonSpam",

     

       38
       38
       +
                 "com.atproto.moderation.defs#reasonViolation",

     

       39
       39
       +
                 "com.atproto.moderation.defs#reasonMisleading",

     

       40
       40
       +
                 "com.atproto.moderation.defs#reasonSexual",

     

       41
       41
       +
                 "com.atproto.moderation.defs#reasonRude",

     

       42
       42
       +
                 "com.atproto.moderation.defs#reasonOther",

     

       43
       43
       +
                 "com.atproto.moderation.defs#reasonAppeal",

     

       44
       44
       +
                 "tools.ozone.report.defs#reasonAppeal",

     

       45
       45
       +
                 "tools.ozone.report.defs#reasonOther",

     

       46
       46
       +
                 "tools.ozone.report.defs#reasonViolenceAnimal",

     

       47
       47
       +
                 "tools.ozone.report.defs#reasonViolenceThreats",

     

       48
       48
       +
                 "tools.ozone.report.defs#reasonViolenceGraphicContent",

     

       49
       49
       +
                 "tools.ozone.report.defs#reasonViolenceGlorification",

     

       50
       50
       +
                 "tools.ozone.report.defs#reasonViolenceExtremistContent",

     

       51
       51
       +
                 "tools.ozone.report.defs#reasonViolenceTrafficking",

     

       52
       52
       +
                 "tools.ozone.report.defs#reasonViolenceOther",

     

       53
       53
       +
                 "tools.ozone.report.defs#reasonSexualAbuseContent",

     

       54
       54
       +
                 "tools.ozone.report.defs#reasonSexualNCII",

     

       55
       55
       +
                 "tools.ozone.report.defs#reasonSexualDeepfake",

     

       56
       56
       +
                 "tools.ozone.report.defs#reasonSexualAnimal",

     

       57
       57
       +
                 "tools.ozone.report.defs#reasonSexualUnlabeled",

     

       58
       58
       +
                 "tools.ozone.report.defs#reasonSexualOther",

     

       59
       59
       +
                 "tools.ozone.report.defs#reasonChildSafetyCSAM",

     

       60
       60
       +
                 "tools.ozone.report.defs#reasonChildSafetyGroom",

     

       61
       61
       +
                 "tools.ozone.report.defs#reasonChildSafetyPrivacy",

     

       62
       62
       +
                 "tools.ozone.report.defs#reasonChildSafetyHarassment",

     

       63
       63
       +
                 "tools.ozone.report.defs#reasonChildSafetyOther",

     

       64
       64
       +
                 "tools.ozone.report.defs#reasonHarassmentTroll",

     

       65
       65
       +
                 "tools.ozone.report.defs#reasonHarassmentTargeted",

     

       66
       66
       +
                 "tools.ozone.report.defs#reasonHarassmentHateSpeech",

     

       67
       67
       +
                 "tools.ozone.report.defs#reasonHarassmentDoxxing",

     

       68
       68
       +
                 "tools.ozone.report.defs#reasonHarassmentOther",

     

       69
       69
       +
                 "tools.ozone.report.defs#reasonMisleadingBot",

     

       70
       70
       +
                 "tools.ozone.report.defs#reasonMisleadingImpersonation",

     

       71
       71
       +
                 "tools.ozone.report.defs#reasonMisleadingSpam",

     

       72
       72
       +
                 "tools.ozone.report.defs#reasonMisleadingScam",

     

       73
       73
       +
                 "tools.ozone.report.defs#reasonMisleadingElections",

     

       74
       74
       +
                 "tools.ozone.report.defs#reasonMisleadingOther",

     

       75
       75
       +
                 "tools.ozone.report.defs#reasonRuleSiteSecurity",

     

       76
       76
       +
                 "tools.ozone.report.defs#reasonRuleProhibitedSales",

     

       77
       77
       +
                 "tools.ozone.report.defs#reasonRuleBanEvasion",

     

       78
       78
       +
                 "tools.ozone.report.defs#reasonRuleOther",

     

       79
       79
       +
                 "tools.ozone.report.defs#reasonSelfHarmContent",

     

       80
       80
       +
                 "tools.ozone.report.defs#reasonSelfHarmED",

     

       81
       81
       +
                 "tools.ozone.report.defs#reasonSelfHarmStunts",

     

       82
       82
       +
                 "tools.ozone.report.defs#reasonSelfHarmSubstances",

     

       83
       83
       +
                 "tools.ozone.report.defs#reasonSelfHarmOther"

     

       84
       84
       +
               ],

     

       85
       85
       +
               "type" => "string"

     

       86
       86
       +
             },

     

       87
       87
       +
             "reasonViolation" => %{

     

       88
       88
       +
               "description" =>

     

       89
       89
       +
                 "Direct violation of server rules, laws, terms of service. Prefer new lexicon definition `tools.ozone.report.defs#reasonRuleOther`.",

     

       90
       90
       +
               "type" => "token"

     

       91
       91
       +
             },

     

       92
       92
       +
             "subjectType" => %{

     

       93
       93
       +
               "description" => "Tag describing a type of subject that might be reported.",

     

       94
       94
       +
               "knownValues" => ["account", "record", "chat"],

     

       95
       95
       +
               "type" => "string"

     

       96
       96
       +
             }

     

       97
       97
       +
           },

     

       98
       98
       +
           "id" => "com.atproto.moderation.defs",

     

       99
       99
       +
           "lexicon" => 1

     

       100
       100
       +
         })

     

       101
       101
       +
       end

+140

lib/atproto/com/atproto/repo/applyWrites.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.ApplyWrites do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "create" => %{

     

       7
       7
       +
               "description" => "Operation which creates a new record.",

     

       8
       8
       +
               "properties" => %{

     

       9
       9
       +
                 "collection" => %{"format" => "nsid", "type" => "string"},

     

       10
       10
       +
                 "rkey" => %{

     

       11
       11
       +
                   "description" =>

     

       12
       12
       +
                     "NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility.",

     

       13
       13
       +
                   "format" => "record-key",

     

       14
       14
       +
                   "maxLength" => 512,

     

       15
       15
       +
                   "type" => "string"

     

       16
       16
       +
                 },

     

       17
       17
       +
                 "value" => %{"type" => "unknown"}

     

       18
       18
       +
               },

     

       19
       19
       +
               "required" => ["collection", "value"],

     

       20
       20
       +
               "type" => "object"

     

       21
       21
       +
             },

     

       22
       22
       +
             "createResult" => %{

     

       23
       23
       +
               "properties" => %{

     

       24
       24
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       25
       25
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"},

     

       26
       26
       +
                 "validationStatus" => %{

     

       27
       27
       +
                   "knownValues" => ["valid", "unknown"],

     

       28
       28
       +
                   "type" => "string"

     

       29
       29
       +
                 }

     

       30
       30
       +
               },

     

       31
       31
       +
               "required" => ["uri", "cid"],

     

       32
       32
       +
               "type" => "object"

     

       33
       33
       +
             },

     

       34
       34
       +
             "delete" => %{

     

       35
       35
       +
               "description" => "Operation which deletes an existing record.",

     

       36
       36
       +
               "properties" => %{

     

       37
       37
       +
                 "collection" => %{"format" => "nsid", "type" => "string"},

     

       38
       38
       +
                 "rkey" => %{"format" => "record-key", "type" => "string"}

     

       39
       39
       +
               },

     

       40
       40
       +
               "required" => ["collection", "rkey"],

     

       41
       41
       +
               "type" => "object"

     

       42
       42
       +
             },

     

       43
       43
       +
             "deleteResult" => %{

     

       44
       44
       +
               "properties" => %{},

     

       45
       45
       +
               "required" => [],

     

       46
       46
       +
               "type" => "object"

     

       47
       47
       +
             },

     

       48
       48
       +
             "main" => %{

     

       49
       49
       +
               "description" =>

     

       50
       50
       +
                 "Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS.",

     

       51
       51
       +
               "errors" => [

     

       52
       52
       +
                 %{

     

       53
       53
       +
                   "description" =>

     

       54
       54
       +
                     "Indicates that the 'swapCommit' parameter did not match current commit.",

     

       55
       55
       +
                   "name" => "InvalidSwap"

     

       56
       56
       +
                 }

     

       57
       57
       +
               ],

     

       58
       58
       +
               "input" => %{

     

       59
       59
       +
                 "encoding" => "application/json",

     

       60
       60
       +
                 "schema" => %{

     

       61
       61
       +
                   "properties" => %{

     

       62
       62
       +
                     "repo" => %{

     

       63
       63
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       64
       64
       +
                       "format" => "at-identifier",

     

       65
       65
       +
                       "type" => "string"

     

       66
       66
       +
                     },

     

       67
       67
       +
                     "swapCommit" => %{

     

       68
       68
       +
                       "description" =>

     

       69
       69
       +
                         "If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations.",

     

       70
       70
       +
                       "format" => "cid",

     

       71
       71
       +
                       "type" => "string"

     

       72
       72
       +
                     },

     

       73
       73
       +
                     "validate" => %{

     

       74
       74
       +
                       "description" =>

     

       75
       75
       +
                         "Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons.",

     

       76
       76
       +
                       "type" => "boolean"

     

       77
       77
       +
                     },

     

       78
       78
       +
                     "writes" => %{

     

       79
       79
       +
                       "items" => %{

     

       80
       80
       +
                         "closed" => true,

     

       81
       81
       +
                         "refs" => ["#create", "#update", "#delete"],

     

       82
       82
       +
                         "type" => "union"

     

       83
       83
       +
                       },

     

       84
       84
       +
                       "type" => "array"

     

       85
       85
       +
                     }

     

       86
       86
       +
                   },

     

       87
       87
       +
                   "required" => ["repo", "writes"],

     

       88
       88
       +
                   "type" => "object"

     

       89
       89
       +
                 }

     

       90
       90
       +
               },

     

       91
       91
       +
               "output" => %{

     

       92
       92
       +
                 "encoding" => "application/json",

     

       93
       93
       +
                 "schema" => %{

     

       94
       94
       +
                   "properties" => %{

     

       95
       95
       +
                     "commit" => %{

     

       96
       96
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       97
       97
       +
                       "type" => "ref"

     

       98
       98
       +
                     },

     

       99
       99
       +
                     "results" => %{

     

       100
       100
       +
                       "items" => %{

     

       101
       101
       +
                         "closed" => true,

     

       102
       102
       +
                         "refs" => ["#createResult", "#updateResult", "#deleteResult"],

     

       103
       103
       +
                         "type" => "union"

     

       104
       104
       +
                       },

     

       105
       105
       +
                       "type" => "array"

     

       106
       106
       +
                     }

     

       107
       107
       +
                   },

     

       108
       108
       +
                   "required" => [],

     

       109
       109
       +
                   "type" => "object"

     

       110
       110
       +
                 }

     

       111
       111
       +
               },

     

       112
       112
       +
               "type" => "procedure"

     

       113
       113
       +
             },

     

       114
       114
       +
             "update" => %{

     

       115
       115
       +
               "description" => "Operation which updates an existing record.",

     

       116
       116
       +
               "properties" => %{

     

       117
       117
       +
                 "collection" => %{"format" => "nsid", "type" => "string"},

     

       118
       118
       +
                 "rkey" => %{"format" => "record-key", "type" => "string"},

     

       119
       119
       +
                 "value" => %{"type" => "unknown"}

     

       120
       120
       +
               },

     

       121
       121
       +
               "required" => ["collection", "rkey", "value"],

     

       122
       122
       +
               "type" => "object"

     

       123
       123
       +
             },

     

       124
       124
       +
             "updateResult" => %{

     

       125
       125
       +
               "properties" => %{

     

       126
       126
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       127
       127
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"},

     

       128
       128
       +
                 "validationStatus" => %{

     

       129
       129
       +
                   "knownValues" => ["valid", "unknown"],

     

       130
       130
       +
                   "type" => "string"

     

       131
       131
       +
                 }

     

       132
       132
       +
               },

     

       133
       133
       +
               "required" => ["uri", "cid"],

     

       134
       134
       +
               "type" => "object"

     

       135
       135
       +
             }

     

       136
       136
       +
           },

     

       137
       137
       +
           "id" => "com.atproto.repo.applyWrites",

     

       138
       138
       +
           "lexicon" => 1

     

       139
       139
       +
         })

     

       140
       140
       +
       end

+79

lib/atproto/com/atproto/repo/createRecord.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.CreateRecord do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Create a single new repository record. Requires auth, implemented by PDS.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{

     

       11
       11
       +
                   "description" => "Indicates that 'swapCommit' didn't match current repo commit.",

     

       12
       12
       +
                   "name" => "InvalidSwap"

     

       13
       13
       +
                 }

     

       14
       14
       +
               ],

     

       15
       15
       +
               "input" => %{

     

       16
       16
       +
                 "encoding" => "application/json",

     

       17
       17
       +
                 "schema" => %{

     

       18
       18
       +
                   "properties" => %{

     

       19
       19
       +
                     "collection" => %{

     

       20
       20
       +
                       "description" => "The NSID of the record collection.",

     

       21
       21
       +
                       "format" => "nsid",

     

       22
       22
       +
                       "type" => "string"

     

       23
       23
       +
                     },

     

       24
       24
       +
                     "record" => %{

     

       25
       25
       +
                       "description" => "The record itself. Must contain a $type field.",

     

       26
       26
       +
                       "type" => "unknown"

     

       27
       27
       +
                     },

     

       28
       28
       +
                     "repo" => %{

     

       29
       29
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       30
       30
       +
                       "format" => "at-identifier",

     

       31
       31
       +
                       "type" => "string"

     

       32
       32
       +
                     },

     

       33
       33
       +
                     "rkey" => %{

     

       34
       34
       +
                       "description" => "The Record Key.",

     

       35
       35
       +
                       "format" => "record-key",

     

       36
       36
       +
                       "maxLength" => 512,

     

       37
       37
       +
                       "type" => "string"

     

       38
       38
       +
                     },

     

       39
       39
       +
                     "swapCommit" => %{

     

       40
       40
       +
                       "description" => "Compare and swap with the previous commit by CID.",

     

       41
       41
       +
                       "format" => "cid",

     

       42
       42
       +
                       "type" => "string"

     

       43
       43
       +
                     },

     

       44
       44
       +
                     "validate" => %{

     

       45
       45
       +
                       "description" =>

     

       46
       46
       +
                         "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",

     

       47
       47
       +
                       "type" => "boolean"

     

       48
       48
       +
                     }

     

       49
       49
       +
                   },

     

       50
       50
       +
                   "required" => ["repo", "collection", "record"],

     

       51
       51
       +
                   "type" => "object"

     

       52
       52
       +
                 }

     

       53
       53
       +
               },

     

       54
       54
       +
               "output" => %{

     

       55
       55
       +
                 "encoding" => "application/json",

     

       56
       56
       +
                 "schema" => %{

     

       57
       57
       +
                   "properties" => %{

     

       58
       58
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       59
       59
       +
                     "commit" => %{

     

       60
       60
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       61
       61
       +
                       "type" => "ref"

     

       62
       62
       +
                     },

     

       63
       63
       +
                     "uri" => %{"format" => "at-uri", "type" => "string"},

     

       64
       64
       +
                     "validationStatus" => %{

     

       65
       65
       +
                       "knownValues" => ["valid", "unknown"],

     

       66
       66
       +
                       "type" => "string"

     

       67
       67
       +
                     }

     

       68
       68
       +
                   },

     

       69
       69
       +
                   "required" => ["uri", "cid"],

     

       70
       70
       +
                   "type" => "object"

     

       71
       71
       +
                 }

     

       72
       72
       +
               },

     

       73
       73
       +
               "type" => "procedure"

     

       74
       74
       +
             }

     

       75
       75
       +
           },

     

       76
       76
       +
           "id" => "com.atproto.repo.createRecord",

     

       77
       77
       +
           "lexicon" => 1

     

       78
       78
       +
         })

     

       79
       79
       +
       end

+18

lib/atproto/com/atproto/repo/defs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.Defs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "commitMeta" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       9
       9
       +
                 "rev" => %{"format" => "tid", "type" => "string"}

     

       10
       10
       +
               },

     

       11
       11
       +
               "required" => ["cid", "rev"],

     

       12
       12
       +
               "type" => "object"

     

       13
       13
       +
             }

     

       14
       14
       +
           },

     

       15
       15
       +
           "id" => "com.atproto.repo.defs",

     

       16
       16
       +
           "lexicon" => 1

     

       17
       17
       +
         })

     

       18
       18
       +
       end

+62

lib/atproto/com/atproto/repo/deleteRecord.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.DeleteRecord do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS.",

     

       9
       9
       +
               "errors" => [%{"name" => "InvalidSwap"}],

     

       10
       10
       +
               "input" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "properties" => %{

     

       14
       14
       +
                     "collection" => %{

     

       15
       15
       +
                       "description" => "The NSID of the record collection.",

     

       16
       16
       +
                       "format" => "nsid",

     

       17
       17
       +
                       "type" => "string"

     

       18
       18
       +
                     },

     

       19
       19
       +
                     "repo" => %{

     

       20
       20
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       21
       21
       +
                       "format" => "at-identifier",

     

       22
       22
       +
                       "type" => "string"

     

       23
       23
       +
                     },

     

       24
       24
       +
                     "rkey" => %{

     

       25
       25
       +
                       "description" => "The Record Key.",

     

       26
       26
       +
                       "format" => "record-key",

     

       27
       27
       +
                       "type" => "string"

     

       28
       28
       +
                     },

     

       29
       29
       +
                     "swapCommit" => %{

     

       30
       30
       +
                       "description" => "Compare and swap with the previous commit by CID.",

     

       31
       31
       +
                       "format" => "cid",

     

       32
       32
       +
                       "type" => "string"

     

       33
       33
       +
                     },

     

       34
       34
       +
                     "swapRecord" => %{

     

       35
       35
       +
                       "description" => "Compare and swap with the previous record by CID.",

     

       36
       36
       +
                       "format" => "cid",

     

       37
       37
       +
                       "type" => "string"

     

       38
       38
       +
                     }

     

       39
       39
       +
                   },

     

       40
       40
       +
                   "required" => ["repo", "collection", "rkey"],

     

       41
       41
       +
                   "type" => "object"

     

       42
       42
       +
                 }

     

       43
       43
       +
               },

     

       44
       44
       +
               "output" => %{

     

       45
       45
       +
                 "encoding" => "application/json",

     

       46
       46
       +
                 "schema" => %{

     

       47
       47
       +
                   "properties" => %{

     

       48
       48
       +
                     "commit" => %{

     

       49
       49
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       50
       50
       +
                       "type" => "ref"

     

       51
       51
       +
                     }

     

       52
       52
       +
                   },

     

       53
       53
       +
                   "type" => "object"

     

       54
       54
       +
                 }

     

       55
       55
       +
               },

     

       56
       56
       +
               "type" => "procedure"

     

       57
       57
       +
             }

     

       58
       58
       +
           },

     

       59
       59
       +
           "id" => "com.atproto.repo.deleteRecord",

     

       60
       60
       +
           "lexicon" => 1

     

       61
       61
       +
         })

     

       62
       62
       +
       end

+52

lib/atproto/com/atproto/repo/describeRepo.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.DescribeRepo do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get information about an account and repository, including the list of collections. Does not require auth.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "collections" => %{

     

       14
       14
       +
                       "description" =>

     

       15
       15
       +
                         "List of all the collections (NSIDs) for which this repo contains at least one record.",

     

       16
       16
       +
                       "items" => %{"format" => "nsid", "type" => "string"},

     

       17
       17
       +
                       "type" => "array"

     

       18
       18
       +
                     },

     

       19
       19
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       20
       20
       +
                     "didDoc" => %{

     

       21
       21
       +
                       "description" => "The complete DID document for this account.",

     

       22
       22
       +
                       "type" => "unknown"

     

       23
       23
       +
                     },

     

       24
       24
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       25
       25
       +
                     "handleIsCorrect" => %{

     

       26
       26
       +
                       "description" =>

     

       27
       27
       +
                         "Indicates if handle is currently valid (resolves bi-directionally)",

     

       28
       28
       +
                       "type" => "boolean"

     

       29
       29
       +
                     }

     

       30
       30
       +
                   },

     

       31
       31
       +
                   "required" => ["handle", "did", "didDoc", "collections", "handleIsCorrect"],

     

       32
       32
       +
                   "type" => "object"

     

       33
       33
       +
                 }

     

       34
       34
       +
               },

     

       35
       35
       +
               "parameters" => %{

     

       36
       36
       +
                 "properties" => %{

     

       37
       37
       +
                   "repo" => %{

     

       38
       38
       +
                     "description" => "The handle or DID of the repo.",

     

       39
       39
       +
                     "format" => "at-identifier",

     

       40
       40
       +
                     "type" => "string"

     

       41
       41
       +
                   }

     

       42
       42
       +
                 },

     

       43
       43
       +
                 "required" => ["repo"],

     

       44
       44
       +
                 "type" => "params"

     

       45
       45
       +
               },

     

       46
       46
       +
               "type" => "query"

     

       47
       47
       +
             }

     

       48
       48
       +
           },

     

       49
       49
       +
           "id" => "com.atproto.repo.describeRepo",

     

       50
       50
       +
           "lexicon" => 1

     

       51
       51
       +
         })

     

       52
       52
       +
       end

+54

lib/atproto/com/atproto/repo/getRecord.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.GetRecord do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Get a single record from a repository. Does not require auth.",

     

       8
       8
       +
               "errors" => [%{"name" => "RecordNotFound"}],

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       14
       14
       +
                     "uri" => %{"format" => "at-uri", "type" => "string"},

     

       15
       15
       +
                     "value" => %{"type" => "unknown"}

     

       16
       16
       +
                   },

     

       17
       17
       +
                   "required" => ["uri", "value"],

     

       18
       18
       +
                   "type" => "object"

     

       19
       19
       +
                 }

     

       20
       20
       +
               },

     

       21
       21
       +
               "parameters" => %{

     

       22
       22
       +
                 "properties" => %{

     

       23
       23
       +
                   "cid" => %{

     

       24
       24
       +
                     "description" =>

     

       25
       25
       +
                       "The CID of the version of the record. If not specified, then return the most recent version.",

     

       26
       26
       +
                     "format" => "cid",

     

       27
       27
       +
                     "type" => "string"

     

       28
       28
       +
                   },

     

       29
       29
       +
                   "collection" => %{

     

       30
       30
       +
                     "description" => "The NSID of the record collection.",

     

       31
       31
       +
                     "format" => "nsid",

     

       32
       32
       +
                     "type" => "string"

     

       33
       33
       +
                   },

     

       34
       34
       +
                   "repo" => %{

     

       35
       35
       +
                     "description" => "The handle or DID of the repo.",

     

       36
       36
       +
                     "format" => "at-identifier",

     

       37
       37
       +
                     "type" => "string"

     

       38
       38
       +
                   },

     

       39
       39
       +
                   "rkey" => %{

     

       40
       40
       +
                     "description" => "The Record Key.",

     

       41
       41
       +
                     "format" => "record-key",

     

       42
       42
       +
                     "type" => "string"

     

       43
       43
       +
                   }

     

       44
       44
       +
                 },

     

       45
       45
       +
                 "required" => ["repo", "collection", "rkey"],

     

       46
       46
       +
                 "type" => "params"

     

       47
       47
       +
               },

     

       48
       48
       +
               "type" => "query"

     

       49
       49
       +
             }

     

       50
       50
       +
           },

     

       51
       51
       +
           "id" => "com.atproto.repo.getRecord",

     

       52
       52
       +
           "lexicon" => 1

     

       53
       53
       +
         })

     

       54
       54
       +
       end

+16

lib/atproto/com/atproto/repo/importRepo.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.ImportRepo do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Import a repo in the form of a CAR file. Requires Content-Length HTTP header to be set.",

     

       9
       9
       +
               "input" => %{"encoding" => "application/vnd.ipld.car"},

     

       10
       10
       +
               "type" => "procedure"

     

       11
       11
       +
             }

     

       12
       12
       +
           },

     

       13
       13
       +
           "id" => "com.atproto.repo.importRepo",

     

       14
       14
       +
           "lexicon" => 1

     

       15
       15
       +
         })

     

       16
       16
       +
       end

+49

lib/atproto/com/atproto/repo/listMissingBlobs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.ListMissingBlobs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Returns a list of missing blobs for the requesting account. Intended to be used in the account migration flow.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "blobs" => %{

     

       14
       14
       +
                       "items" => %{"ref" => "#recordBlob", "type" => "ref"},

     

       15
       15
       +
                       "type" => "array"

     

       16
       16
       +
                     },

     

       17
       17
       +
                     "cursor" => %{"type" => "string"}

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["blobs"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "parameters" => %{

     

       24
       24
       +
                 "properties" => %{

     

       25
       25
       +
                   "cursor" => %{"type" => "string"},

     

       26
       26
       +
                   "limit" => %{

     

       27
       27
       +
                     "default" => 500,

     

       28
       28
       +
                     "maximum" => 1000,

     

       29
       29
       +
                     "minimum" => 1,

     

       30
       30
       +
                     "type" => "integer"

     

       31
       31
       +
                   }

     

       32
       32
       +
                 },

     

       33
       33
       +
                 "type" => "params"

     

       34
       34
       +
               },

     

       35
       35
       +
               "type" => "query"

     

       36
       36
       +
             },

     

       37
       37
       +
             "recordBlob" => %{

     

       38
       38
       +
               "properties" => %{

     

       39
       39
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       40
       40
       +
                 "recordUri" => %{"format" => "at-uri", "type" => "string"}

     

       41
       41
       +
               },

     

       42
       42
       +
               "required" => ["cid", "recordUri"],

     

       43
       43
       +
               "type" => "object"

     

       44
       44
       +
             }

     

       45
       45
       +
           },

     

       46
       46
       +
           "id" => "com.atproto.repo.listMissingBlobs",

     

       47
       47
       +
           "lexicon" => 1

     

       48
       48
       +
         })

     

       49
       49
       +
       end

+66

lib/atproto/com/atproto/repo/listRecords.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.ListRecords do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "List a range of records in a repository, matching a specific collection. Does not require auth.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       14
       +
                     "records" => %{

     

       15
       15
       +
                       "items" => %{"ref" => "#record", "type" => "ref"},

     

       16
       16
       +
                       "type" => "array"

     

       17
       17
       +
                     }

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["records"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "parameters" => %{

     

       24
       24
       +
                 "properties" => %{

     

       25
       25
       +
                   "collection" => %{

     

       26
       26
       +
                     "description" => "The NSID of the record type.",

     

       27
       27
       +
                     "format" => "nsid",

     

       28
       28
       +
                     "type" => "string"

     

       29
       29
       +
                   },

     

       30
       30
       +
                   "cursor" => %{"type" => "string"},

     

       31
       31
       +
                   "limit" => %{

     

       32
       32
       +
                     "default" => 50,

     

       33
       33
       +
                     "description" => "The number of records to return.",

     

       34
       34
       +
                     "maximum" => 100,

     

       35
       35
       +
                     "minimum" => 1,

     

       36
       36
       +
                     "type" => "integer"

     

       37
       37
       +
                   },

     

       38
       38
       +
                   "repo" => %{

     

       39
       39
       +
                     "description" => "The handle or DID of the repo.",

     

       40
       40
       +
                     "format" => "at-identifier",

     

       41
       41
       +
                     "type" => "string"

     

       42
       42
       +
                   },

     

       43
       43
       +
                   "reverse" => %{

     

       44
       44
       +
                     "description" => "Flag to reverse the order of the returned records.",

     

       45
       45
       +
                     "type" => "boolean"

     

       46
       46
       +
                   }

     

       47
       47
       +
                 },

     

       48
       48
       +
                 "required" => ["repo", "collection"],

     

       49
       49
       +
                 "type" => "params"

     

       50
       50
       +
               },

     

       51
       51
       +
               "type" => "query"

     

       52
       52
       +
             },

     

       53
       53
       +
             "record" => %{

     

       54
       54
       +
               "properties" => %{

     

       55
       55
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       56
       56
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"},

     

       57
       57
       +
                 "value" => %{"type" => "unknown"}

     

       58
       58
       +
               },

     

       59
       59
       +
               "required" => ["uri", "cid", "value"],

     

       60
       60
       +
               "type" => "object"

     

       61
       61
       +
             }

     

       62
       62
       +
           },

     

       63
       63
       +
           "id" => "com.atproto.repo.listRecords",

     

       64
       64
       +
           "lexicon" => 1

     

       65
       65
       +
         })

     

       66
       66
       +
       end

+81

lib/atproto/com/atproto/repo/putRecord.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.PutRecord do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS.",

     

       9
       9
       +
               "errors" => [%{"name" => "InvalidSwap"}],

     

       10
       10
       +
               "input" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "nullable" => ["swapRecord"],

     

       14
       14
       +
                   "properties" => %{

     

       15
       15
       +
                     "collection" => %{

     

       16
       16
       +
                       "description" => "The NSID of the record collection.",

     

       17
       17
       +
                       "format" => "nsid",

     

       18
       18
       +
                       "type" => "string"

     

       19
       19
       +
                     },

     

       20
       20
       +
                     "record" => %{

     

       21
       21
       +
                       "description" => "The record to write.",

     

       22
       22
       +
                       "type" => "unknown"

     

       23
       23
       +
                     },

     

       24
       24
       +
                     "repo" => %{

     

       25
       25
       +
                       "description" => "The handle or DID of the repo (aka, current account).",

     

       26
       26
       +
                       "format" => "at-identifier",

     

       27
       27
       +
                       "type" => "string"

     

       28
       28
       +
                     },

     

       29
       29
       +
                     "rkey" => %{

     

       30
       30
       +
                       "description" => "The Record Key.",

     

       31
       31
       +
                       "format" => "record-key",

     

       32
       32
       +
                       "maxLength" => 512,

     

       33
       33
       +
                       "type" => "string"

     

       34
       34
       +
                     },

     

       35
       35
       +
                     "swapCommit" => %{

     

       36
       36
       +
                       "description" => "Compare and swap with the previous commit by CID.",

     

       37
       37
       +
                       "format" => "cid",

     

       38
       38
       +
                       "type" => "string"

     

       39
       39
       +
                     },

     

       40
       40
       +
                     "swapRecord" => %{

     

       41
       41
       +
                       "description" =>

     

       42
       42
       +
                         "Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation",

     

       43
       43
       +
                       "format" => "cid",

     

       44
       44
       +
                       "type" => "string"

     

       45
       45
       +
                     },

     

       46
       46
       +
                     "validate" => %{

     

       47
       47
       +
                       "description" =>

     

       48
       48
       +
                         "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",

     

       49
       49
       +
                       "type" => "boolean"

     

       50
       50
       +
                     }

     

       51
       51
       +
                   },

     

       52
       52
       +
                   "required" => ["repo", "collection", "rkey", "record"],

     

       53
       53
       +
                   "type" => "object"

     

       54
       54
       +
                 }

     

       55
       55
       +
               },

     

       56
       56
       +
               "output" => %{

     

       57
       57
       +
                 "encoding" => "application/json",

     

       58
       58
       +
                 "schema" => %{

     

       59
       59
       +
                   "properties" => %{

     

       60
       60
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       61
       61
       +
                     "commit" => %{

     

       62
       62
       +
                       "ref" => "com.atproto.repo.defs#commitMeta",

     

       63
       63
       +
                       "type" => "ref"

     

       64
       64
       +
                     },

     

       65
       65
       +
                     "uri" => %{"format" => "at-uri", "type" => "string"},

     

       66
       66
       +
                     "validationStatus" => %{

     

       67
       67
       +
                       "knownValues" => ["valid", "unknown"],

     

       68
       68
       +
                       "type" => "string"

     

       69
       69
       +
                     }

     

       70
       70
       +
                   },

     

       71
       71
       +
                   "required" => ["uri", "cid"],

     

       72
       72
       +
                   "type" => "object"

     

       73
       73
       +
                 }

     

       74
       74
       +
               },

     

       75
       75
       +
               "type" => "procedure"

     

       76
       76
       +
             }

     

       77
       77
       +
           },

     

       78
       78
       +
           "id" => "com.atproto.repo.putRecord",

     

       79
       79
       +
           "lexicon" => 1

     

       80
       80
       +
         })

     

       81
       81
       +
       end

+19

lib/atproto/com/atproto/repo/strongRef.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.StrongRef do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "cid" => %{"format" => "cid", "type" => "string"},

     

       9
       9
       +
                 "uri" => %{"format" => "at-uri", "type" => "string"}

     

       10
       10
       +
               },

     

       11
       11
       +
               "required" => ["uri", "cid"],

     

       12
       12
       +
               "type" => "object"

     

       13
       13
       +
             }

     

       14
       14
       +
           },

     

       15
       15
       +
           "description" => "A URI with a content-hash fingerprint.",

     

       16
       16
       +
           "id" => "com.atproto.repo.strongRef",

     

       17
       17
       +
           "lexicon" => 1

     

       18
       18
       +
         })

     

       19
       19
       +
       end

+24

lib/atproto/com/atproto/repo/uploadBlob.ex

···

       1
       1
       +
       defmodule Com.Atproto.Repo.UploadBlob do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS.",

     

       9
       9
       +
               "input" => %{"encoding" => "*/*"},

     

       10
       10
       +
               "output" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "properties" => %{"blob" => %{"type" => "blob"}},

     

       14
       14
       +
                   "required" => ["blob"],

     

       15
       15
       +
                   "type" => "object"

     

       16
       16
       +
                 }

     

       17
       17
       +
               },

     

       18
       18
       +
               "type" => "procedure"

     

       19
       19
       +
             }

     

       20
       20
       +
           },

     

       21
       21
       +
           "id" => "com.atproto.repo.uploadBlob",

     

       22
       22
       +
           "lexicon" => 1

     

       23
       23
       +
         })

     

       24
       24
       +
       end

+15

lib/atproto/com/atproto/server/activateAccount.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.ActivateAccount do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Activates a currently deactivated account. Used to finalize account migration after the account's repo is imported and identity is setup.",

     

       9
       9
       +
               "type" => "procedure"

     

       10
       10
       +
             }

     

       11
       11
       +
           },

     

       12
       12
       +
           "id" => "com.atproto.server.activateAccount",

     

       13
       13
       +
           "lexicon" => 1

     

       14
       14
       +
         })

     

       15
       15
       +
       end

+43

lib/atproto/com/atproto/server/checkAccountStatus.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.CheckAccountStatus do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Returns the status of an account, especially as pertaining to import or recovery. Can be called many times over the course of an account migration. Requires auth and can only be called pertaining to oneself.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "activated" => %{"type" => "boolean"},

     

       14
       14
       +
                     "expectedBlobs" => %{"type" => "integer"},

     

       15
       15
       +
                     "importedBlobs" => %{"type" => "integer"},

     

       16
       16
       +
                     "indexedRecords" => %{"type" => "integer"},

     

       17
       17
       +
                     "privateStateValues" => %{"type" => "integer"},

     

       18
       18
       +
                     "repoBlocks" => %{"type" => "integer"},

     

       19
       19
       +
                     "repoCommit" => %{"format" => "cid", "type" => "string"},

     

       20
       20
       +
                     "repoRev" => %{"type" => "string"},

     

       21
       21
       +
                     "validDid" => %{"type" => "boolean"}

     

       22
       22
       +
                   },

     

       23
       23
       +
                   "required" => [

     

       24
       24
       +
                     "activated",

     

       25
       25
       +
                     "validDid",

     

       26
       26
       +
                     "repoCommit",

     

       27
       27
       +
                     "repoRev",

     

       28
       28
       +
                     "repoBlocks",

     

       29
       29
       +
                     "indexedRecords",

     

       30
       30
       +
                     "privateStateValues",

     

       31
       31
       +
                     "expectedBlobs",

     

       32
       32
       +
                     "importedBlobs"

     

       33
       33
       +
                   ],

     

       34
       34
       +
                   "type" => "object"

     

       35
       35
       +
                 }

     

       36
       36
       +
               },

     

       37
       37
       +
               "type" => "query"

     

       38
       38
       +
             }

     

       39
       39
       +
           },

     

       40
       40
       +
           "id" => "com.atproto.server.checkAccountStatus",

     

       41
       41
       +
           "lexicon" => 1

     

       42
       42
       +
         })

     

       43
       43
       +
       end

+32

lib/atproto/com/atproto/server/confirmEmail.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.ConfirmEmail do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Confirm an email using a token from com.atproto.server.requestEmailConfirmation.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{"name" => "AccountNotFound"},

     

       11
       11
       +
                 %{"name" => "ExpiredToken"},

     

       12
       12
       +
                 %{"name" => "InvalidToken"},

     

       13
       13
       +
                 %{"name" => "InvalidEmail"}

     

       14
       14
       +
               ],

     

       15
       15
       +
               "input" => %{

     

       16
       16
       +
                 "encoding" => "application/json",

     

       17
       17
       +
                 "schema" => %{

     

       18
       18
       +
                   "properties" => %{

     

       19
       19
       +
                     "email" => %{"type" => "string"},

     

       20
       20
       +
                     "token" => %{"type" => "string"}

     

       21
       21
       +
                   },

     

       22
       22
       +
                   "required" => ["email", "token"],

     

       23
       23
       +
                   "type" => "object"

     

       24
       24
       +
                 }

     

       25
       25
       +
               },

     

       26
       26
       +
               "type" => "procedure"

     

       27
       27
       +
             }

     

       28
       28
       +
           },

     

       29
       29
       +
           "id" => "com.atproto.server.confirmEmail",

     

       30
       30
       +
           "lexicon" => 1

     

       31
       31
       +
         })

     

       32
       32
       +
       end

+83

lib/atproto/com/atproto/server/createAccount.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.CreateAccount do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Create an account. Implemented by PDS.",

     

       8
       8
       +
               "errors" => [

     

       9
       9
       +
                 %{"name" => "InvalidHandle"},

     

       10
       10
       +
                 %{"name" => "InvalidPassword"},

     

       11
       11
       +
                 %{"name" => "InvalidInviteCode"},

     

       12
       12
       +
                 %{"name" => "HandleNotAvailable"},

     

       13
       13
       +
                 %{"name" => "UnsupportedDomain"},

     

       14
       14
       +
                 %{"name" => "UnresolvableDid"},

     

       15
       15
       +
                 %{"name" => "IncompatibleDidDoc"}

     

       16
       16
       +
               ],

     

       17
       17
       +
               "input" => %{

     

       18
       18
       +
                 "encoding" => "application/json",

     

       19
       19
       +
                 "schema" => %{

     

       20
       20
       +
                   "properties" => %{

     

       21
       21
       +
                     "did" => %{

     

       22
       22
       +
                       "description" => "Pre-existing atproto DID, being imported to a new account.",

     

       23
       23
       +
                       "format" => "did",

     

       24
       24
       +
                       "type" => "string"

     

       25
       25
       +
                     },

     

       26
       26
       +
                     "email" => %{"type" => "string"},

     

       27
       27
       +
                     "handle" => %{

     

       28
       28
       +
                       "description" => "Requested handle for the account.",

     

       29
       29
       +
                       "format" => "handle",

     

       30
       30
       +
                       "type" => "string"

     

       31
       31
       +
                     },

     

       32
       32
       +
                     "inviteCode" => %{"type" => "string"},

     

       33
       33
       +
                     "password" => %{

     

       34
       34
       +
                       "description" =>

     

       35
       35
       +
                         "Initial account password. May need to meet instance-specific password strength requirements.",

     

       36
       36
       +
                       "type" => "string"

     

       37
       37
       +
                     },

     

       38
       38
       +
                     "plcOp" => %{

     

       39
       39
       +
                       "description" =>

     

       40
       40
       +
                         "A signed DID PLC operation to be submitted as part of importing an existing account to this instance. NOTE: this optional field may be updated when full account migration is implemented.",

     

       41
       41
       +
                       "type" => "unknown"

     

       42
       42
       +
                     },

     

       43
       43
       +
                     "recoveryKey" => %{

     

       44
       44
       +
                       "description" =>

     

       45
       45
       +
                         "DID PLC rotation key (aka, recovery key) to be included in PLC creation operation.",

     

       46
       46
       +
                       "type" => "string"

     

       47
       47
       +
                     },

     

       48
       48
       +
                     "verificationCode" => %{"type" => "string"},

     

       49
       49
       +
                     "verificationPhone" => %{"type" => "string"}

     

       50
       50
       +
                   },

     

       51
       51
       +
                   "required" => ["handle"],

     

       52
       52
       +
                   "type" => "object"

     

       53
       53
       +
                 }

     

       54
       54
       +
               },

     

       55
       55
       +
               "output" => %{

     

       56
       56
       +
                 "encoding" => "application/json",

     

       57
       57
       +
                 "schema" => %{

     

       58
       58
       +
                   "description" => "Account login session returned on successful account creation.",

     

       59
       59
       +
                   "properties" => %{

     

       60
       60
       +
                     "accessJwt" => %{"type" => "string"},

     

       61
       61
       +
                     "did" => %{

     

       62
       62
       +
                       "description" => "The DID of the new account.",

     

       63
       63
       +
                       "format" => "did",

     

       64
       64
       +
                       "type" => "string"

     

       65
       65
       +
                     },

     

       66
       66
       +
                     "didDoc" => %{

     

       67
       67
       +
                       "description" => "Complete DID document.",

     

       68
       68
       +
                       "type" => "unknown"

     

       69
       69
       +
                     },

     

       70
       70
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       71
       71
       +
                     "refreshJwt" => %{"type" => "string"}

     

       72
       72
       +
                   },

     

       73
       73
       +
                   "required" => ["accessJwt", "refreshJwt", "handle", "did"],

     

       74
       74
       +
                   "type" => "object"

     

       75
       75
       +
                 }

     

       76
       76
       +
               },

     

       77
       77
       +
               "type" => "procedure"

     

       78
       78
       +
             }

     

       79
       79
       +
           },

     

       80
       80
       +
           "id" => "com.atproto.server.createAccount",

     

       81
       81
       +
           "lexicon" => 1

     

       82
       82
       +
         })

     

       83
       83
       +
       end

+47

lib/atproto/com/atproto/server/createAppPassword.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.CreateAppPassword do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "appPassword" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       9
       9
       +
                 "name" => %{"type" => "string"},

     

       10
       10
       +
                 "password" => %{"type" => "string"},

     

       11
       11
       +
                 "privileged" => %{"type" => "boolean"}

     

       12
       12
       +
               },

     

       13
       13
       +
               "required" => ["name", "password", "createdAt"],

     

       14
       14
       +
               "type" => "object"

     

       15
       15
       +
             },

     

       16
       16
       +
             "main" => %{

     

       17
       17
       +
               "description" => "Create an App Password.",

     

       18
       18
       +
               "errors" => [%{"name" => "AccountTakedown"}],

     

       19
       19
       +
               "input" => %{

     

       20
       20
       +
                 "encoding" => "application/json",

     

       21
       21
       +
                 "schema" => %{

     

       22
       22
       +
                   "properties" => %{

     

       23
       23
       +
                     "name" => %{

     

       24
       24
       +
                       "description" => "A short name for the App Password, to help distinguish them.",

     

       25
       25
       +
                       "type" => "string"

     

       26
       26
       +
                     },

     

       27
       27
       +
                     "privileged" => %{

     

       28
       28
       +
                       "description" =>

     

       29
       29
       +
                         "If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients.",

     

       30
       30
       +
                       "type" => "boolean"

     

       31
       31
       +
                     }

     

       32
       32
       +
                   },

     

       33
       33
       +
                   "required" => ["name"],

     

       34
       34
       +
                   "type" => "object"

     

       35
       35
       +
                 }

     

       36
       36
       +
               },

     

       37
       37
       +
               "output" => %{

     

       38
       38
       +
                 "encoding" => "application/json",

     

       39
       39
       +
                 "schema" => %{"ref" => "#appPassword", "type" => "ref"}

     

       40
       40
       +
               },

     

       41
       41
       +
               "type" => "procedure"

     

       42
       42
       +
             }

     

       43
       43
       +
           },

     

       44
       44
       +
           "id" => "com.atproto.server.createAppPassword",

     

       45
       45
       +
           "lexicon" => 1

     

       46
       46
       +
         })

     

       47
       47
       +
       end

+33

lib/atproto/com/atproto/server/createInviteCode.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.CreateInviteCode do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Create an invite code.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "forAccount" => %{"format" => "did", "type" => "string"},

     

       13
       13
       +
                     "useCount" => %{"type" => "integer"}

     

       14
       14
       +
                   },

     

       15
       15
       +
                   "required" => ["useCount"],

     

       16
       16
       +
                   "type" => "object"

     

       17
       17
       +
                 }

     

       18
       18
       +
               },

     

       19
       19
       +
               "output" => %{

     

       20
       20
       +
                 "encoding" => "application/json",

     

       21
       21
       +
                 "schema" => %{

     

       22
       22
       +
                   "properties" => %{"code" => %{"type" => "string"}},

     

       23
       23
       +
                   "required" => ["code"],

     

       24
       24
       +
                   "type" => "object"

     

       25
       25
       +
                 }

     

       26
       26
       +
               },

     

       27
       27
       +
               "type" => "procedure"

     

       28
       28
       +
             }

     

       29
       29
       +
           },

     

       30
       30
       +
           "id" => "com.atproto.server.createInviteCode",

     

       31
       31
       +
           "lexicon" => 1

     

       32
       32
       +
         })

     

       33
       33
       +
       end

+50

lib/atproto/com/atproto/server/createInviteCodes.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.CreateInviteCodes do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "accountCodes" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "account" => %{"type" => "string"},

     

       9
       9
       +
                 "codes" => %{"items" => %{"type" => "string"}, "type" => "array"}

     

       10
       10
       +
               },

     

       11
       11
       +
               "required" => ["account", "codes"],

     

       12
       12
       +
               "type" => "object"

     

       13
       13
       +
             },

     

       14
       14
       +
             "main" => %{

     

       15
       15
       +
               "description" => "Create invite codes.",

     

       16
       16
       +
               "input" => %{

     

       17
       17
       +
                 "encoding" => "application/json",

     

       18
       18
       +
                 "schema" => %{

     

       19
       19
       +
                   "properties" => %{

     

       20
       20
       +
                     "codeCount" => %{"default" => 1, "type" => "integer"},

     

       21
       21
       +
                     "forAccounts" => %{

     

       22
       22
       +
                       "items" => %{"format" => "did", "type" => "string"},

     

       23
       23
       +
                       "type" => "array"

     

       24
       24
       +
                     },

     

       25
       25
       +
                     "useCount" => %{"type" => "integer"}

     

       26
       26
       +
                   },

     

       27
       27
       +
                   "required" => ["codeCount", "useCount"],

     

       28
       28
       +
                   "type" => "object"

     

       29
       29
       +
                 }

     

       30
       30
       +
               },

     

       31
       31
       +
               "output" => %{

     

       32
       32
       +
                 "encoding" => "application/json",

     

       33
       33
       +
                 "schema" => %{

     

       34
       34
       +
                   "properties" => %{

     

       35
       35
       +
                     "codes" => %{

     

       36
       36
       +
                       "items" => %{"ref" => "#accountCodes", "type" => "ref"},

     

       37
       37
       +
                       "type" => "array"

     

       38
       38
       +
                     }

     

       39
       39
       +
                   },

     

       40
       40
       +
                   "required" => ["codes"],

     

       41
       41
       +
                   "type" => "object"

     

       42
       42
       +
                 }

     

       43
       43
       +
               },

     

       44
       44
       +
               "type" => "procedure"

     

       45
       45
       +
             }

     

       46
       46
       +
           },

     

       47
       47
       +
           "id" => "com.atproto.server.createInviteCodes",

     

       48
       48
       +
           "lexicon" => 1

     

       49
       49
       +
         })

     

       50
       50
       +
       end

+63

lib/atproto/com/atproto/server/createSession.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.CreateSession do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Create an authentication session.",

     

       8
       8
       +
               "errors" => [

     

       9
       9
       +
                 %{"name" => "AccountTakedown"},

     

       10
       10
       +
                 %{"name" => "AuthFactorTokenRequired"}

     

       11
       11
       +
               ],

     

       12
       12
       +
               "input" => %{

     

       13
       13
       +
                 "encoding" => "application/json",

     

       14
       14
       +
                 "schema" => %{

     

       15
       15
       +
                   "properties" => %{

     

       16
       16
       +
                     "allowTakendown" => %{

     

       17
       17
       +
                       "description" =>

     

       18
       18
       +
                         "When true, instead of throwing error for takendown accounts, a valid response with a narrow scoped token will be returned",

     

       19
       19
       +
                       "type" => "boolean"

     

       20
       20
       +
                     },

     

       21
       21
       +
                     "authFactorToken" => %{"type" => "string"},

     

       22
       22
       +
                     "identifier" => %{

     

       23
       23
       +
                       "description" =>

     

       24
       24
       +
                         "Handle or other identifier supported by the server for the authenticating user.",

     

       25
       25
       +
                       "type" => "string"

     

       26
       26
       +
                     },

     

       27
       27
       +
                     "password" => %{"type" => "string"}

     

       28
       28
       +
                   },

     

       29
       29
       +
                   "required" => ["identifier", "password"],

     

       30
       30
       +
                   "type" => "object"

     

       31
       31
       +
                 }

     

       32
       32
       +
               },

     

       33
       33
       +
               "output" => %{

     

       34
       34
       +
                 "encoding" => "application/json",

     

       35
       35
       +
                 "schema" => %{

     

       36
       36
       +
                   "properties" => %{

     

       37
       37
       +
                     "accessJwt" => %{"type" => "string"},

     

       38
       38
       +
                     "active" => %{"type" => "boolean"},

     

       39
       39
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       40
       40
       +
                     "didDoc" => %{"type" => "unknown"},

     

       41
       41
       +
                     "email" => %{"type" => "string"},

     

       42
       42
       +
                     "emailAuthFactor" => %{"type" => "boolean"},

     

       43
       43
       +
                     "emailConfirmed" => %{"type" => "boolean"},

     

       44
       44
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       45
       45
       +
                     "refreshJwt" => %{"type" => "string"},

     

       46
       46
       +
                     "status" => %{

     

       47
       47
       +
                       "description" =>

     

       48
       48
       +
                         "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",

     

       49
       49
       +
                       "knownValues" => ["takendown", "suspended", "deactivated"],

     

       50
       50
       +
                       "type" => "string"

     

       51
       51
       +
                     }

     

       52
       52
       +
                   },

     

       53
       53
       +
                   "required" => ["accessJwt", "refreshJwt", "handle", "did"],

     

       54
       54
       +
                   "type" => "object"

     

       55
       55
       +
                 }

     

       56
       56
       +
               },

     

       57
       57
       +
               "type" => "procedure"

     

       58
       58
       +
             }

     

       59
       59
       +
           },

     

       60
       60
       +
           "id" => "com.atproto.server.createSession",

     

       61
       61
       +
           "lexicon" => 1

     

       62
       62
       +
         })

     

       63
       63
       +
       end

+29

lib/atproto/com/atproto/server/deactivateAccount.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.DeactivateAccount do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Deactivates a currently active account. Stops serving of repo, and future writes to repo until reactivated. Used to finalize account migration with the old host after the account has been activated on the new host.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "deleteAfter" => %{

     

       14
       14
       +
                       "description" =>

     

       15
       15
       +
                         "A recommendation to server as to how long they should hold onto the deactivated account before deleting.",

     

       16
       16
       +
                       "format" => "datetime",

     

       17
       17
       +
                       "type" => "string"

     

       18
       18
       +
                     }

     

       19
       19
       +
                   },

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "type" => "procedure"

     

       24
       24
       +
             }

     

       25
       25
       +
           },

     

       26
       26
       +
           "id" => "com.atproto.server.deactivateAccount",

     

       27
       27
       +
           "lexicon" => 1

     

       28
       28
       +
         })

     

       29
       29
       +
       end

+42

lib/atproto/com/atproto/server/defs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.Defs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "inviteCode" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "available" => %{"type" => "integer"},

     

       9
       9
       +
                 "code" => %{"type" => "string"},

     

       10
       10
       +
                 "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       11
       11
       +
                 "createdBy" => %{"type" => "string"},

     

       12
       12
       +
                 "disabled" => %{"type" => "boolean"},

     

       13
       13
       +
                 "forAccount" => %{"type" => "string"},

     

       14
       14
       +
                 "uses" => %{

     

       15
       15
       +
                   "items" => %{"ref" => "#inviteCodeUse", "type" => "ref"},

     

       16
       16
       +
                   "type" => "array"

     

       17
       17
       +
                 }

     

       18
       18
       +
               },

     

       19
       19
       +
               "required" => [

     

       20
       20
       +
                 "code",

     

       21
       21
       +
                 "available",

     

       22
       22
       +
                 "disabled",

     

       23
       23
       +
                 "forAccount",

     

       24
       24
       +
                 "createdBy",

     

       25
       25
       +
                 "createdAt",

     

       26
       26
       +
                 "uses"

     

       27
       27
       +
               ],

     

       28
       28
       +
               "type" => "object"

     

       29
       29
       +
             },

     

       30
       30
       +
             "inviteCodeUse" => %{

     

       31
       31
       +
               "properties" => %{

     

       32
       32
       +
                 "usedAt" => %{"format" => "datetime", "type" => "string"},

     

       33
       33
       +
                 "usedBy" => %{"format" => "did", "type" => "string"}

     

       34
       34
       +
               },

     

       35
       35
       +
               "required" => ["usedBy", "usedAt"],

     

       36
       36
       +
               "type" => "object"

     

       37
       37
       +
             }

     

       38
       38
       +
           },

     

       39
       39
       +
           "id" => "com.atproto.server.defs",

     

       40
       40
       +
           "lexicon" => 1

     

       41
       41
       +
         })

     

       42
       42
       +
       end

+28

lib/atproto/com/atproto/server/deleteAccount.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.DeleteAccount do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Delete an actor's account with a token and password. Can only be called after requesting a deletion token. Requires auth.",

     

       9
       9
       +
               "errors" => [%{"name" => "ExpiredToken"}, %{"name" => "InvalidToken"}],

     

       10
       10
       +
               "input" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "properties" => %{

     

       14
       14
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       15
       15
       +
                     "password" => %{"type" => "string"},

     

       16
       16
       +
                     "token" => %{"type" => "string"}

     

       17
       17
       +
                   },

     

       18
       18
       +
                   "required" => ["did", "password", "token"],

     

       19
       19
       +
                   "type" => "object"

     

       20
       20
       +
                 }

     

       21
       21
       +
               },

     

       22
       22
       +
               "type" => "procedure"

     

       23
       23
       +
             }

     

       24
       24
       +
           },

     

       25
       25
       +
           "id" => "com.atproto.server.deleteAccount",

     

       26
       26
       +
           "lexicon" => 1

     

       27
       27
       +
         })

     

       28
       28
       +
       end

+14

lib/atproto/com/atproto/server/deleteSession.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.DeleteSession do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Delete the current session. Requires auth.",

     

       8
       8
       +
               "type" => "procedure"

     

       9
       9
       +
             }

     

       10
       10
       +
           },

     

       11
       11
       +
           "id" => "com.atproto.server.deleteSession",

     

       12
       12
       +
           "lexicon" => 1

     

       13
       13
       +
         })

     

       14
       14
       +
       end

+61

lib/atproto/com/atproto/server/describeServer.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.DescribeServer do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "contact" => %{

     

       7
       7
       +
               "properties" => %{"email" => %{"type" => "string"}},

     

       8
       8
       +
               "type" => "object"

     

       9
       9
       +
             },

     

       10
       10
       +
             "links" => %{

     

       11
       11
       +
               "properties" => %{

     

       12
       12
       +
                 "privacyPolicy" => %{"format" => "uri", "type" => "string"},

     

       13
       13
       +
                 "termsOfService" => %{"format" => "uri", "type" => "string"}

     

       14
       14
       +
               },

     

       15
       15
       +
               "type" => "object"

     

       16
       16
       +
             },

     

       17
       17
       +
             "main" => %{

     

       18
       18
       +
               "description" =>

     

       19
       19
       +
                 "Describes the server's account creation requirements and capabilities. Implemented by PDS.",

     

       20
       20
       +
               "output" => %{

     

       21
       21
       +
                 "encoding" => "application/json",

     

       22
       22
       +
                 "schema" => %{

     

       23
       23
       +
                   "properties" => %{

     

       24
       24
       +
                     "availableUserDomains" => %{

     

       25
       25
       +
                       "description" => "List of domain suffixes that can be used in account handles.",

     

       26
       26
       +
                       "items" => %{"type" => "string"},

     

       27
       27
       +
                       "type" => "array"

     

       28
       28
       +
                     },

     

       29
       29
       +
                     "contact" => %{

     

       30
       30
       +
                       "description" => "Contact information",

     

       31
       31
       +
                       "ref" => "#contact",

     

       32
       32
       +
                       "type" => "ref"

     

       33
       33
       +
                     },

     

       34
       34
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       35
       35
       +
                     "inviteCodeRequired" => %{

     

       36
       36
       +
                       "description" =>

     

       37
       37
       +
                         "If true, an invite code must be supplied to create an account on this instance.",

     

       38
       38
       +
                       "type" => "boolean"

     

       39
       39
       +
                     },

     

       40
       40
       +
                     "links" => %{

     

       41
       41
       +
                       "description" => "URLs of service policy documents.",

     

       42
       42
       +
                       "ref" => "#links",

     

       43
       43
       +
                       "type" => "ref"

     

       44
       44
       +
                     },

     

       45
       45
       +
                     "phoneVerificationRequired" => %{

     

       46
       46
       +
                       "description" =>

     

       47
       47
       +
                         "If true, a phone verification token must be supplied to create an account on this instance.",

     

       48
       48
       +
                       "type" => "boolean"

     

       49
       49
       +
                     }

     

       50
       50
       +
                   },

     

       51
       51
       +
                   "required" => ["did", "availableUserDomains"],

     

       52
       52
       +
                   "type" => "object"

     

       53
       53
       +
                 }

     

       54
       54
       +
               },

     

       55
       55
       +
               "type" => "query"

     

       56
       56
       +
             }

     

       57
       57
       +
           },

     

       58
       58
       +
           "id" => "com.atproto.server.describeServer",

     

       59
       59
       +
           "lexicon" => 1

     

       60
       60
       +
         })

     

       61
       61
       +
       end

+43

lib/atproto/com/atproto/server/getAccountInviteCodes.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.GetAccountInviteCodes do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Get all invite codes for the current account. Requires auth.",

     

       8
       8
       +
               "errors" => [%{"name" => "DuplicateCreate"}],

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "codes" => %{

     

       14
       14
       +
                       "items" => %{

     

       15
       15
       +
                         "ref" => "com.atproto.server.defs#inviteCode",

     

       16
       16
       +
                         "type" => "ref"

     

       17
       17
       +
                       },

     

       18
       18
       +
                       "type" => "array"

     

       19
       19
       +
                     }

     

       20
       20
       +
                   },

     

       21
       21
       +
                   "required" => ["codes"],

     

       22
       22
       +
                   "type" => "object"

     

       23
       23
       +
                 }

     

       24
       24
       +
               },

     

       25
       25
       +
               "parameters" => %{

     

       26
       26
       +
                 "properties" => %{

     

       27
       27
       +
                   "createAvailable" => %{

     

       28
       28
       +
                     "default" => true,

     

       29
       29
       +
                     "description" =>

     

       30
       30
       +
                       "Controls whether any new 'earned' but not 'created' invites should be created.",

     

       31
       31
       +
                     "type" => "boolean"

     

       32
       32
       +
                   },

     

       33
       33
       +
                   "includeUsed" => %{"default" => true, "type" => "boolean"}

     

       34
       34
       +
                 },

     

       35
       35
       +
                 "type" => "params"

     

       36
       36
       +
               },

     

       37
       37
       +
               "type" => "query"

     

       38
       38
       +
             }

     

       39
       39
       +
           },

     

       40
       40
       +
           "id" => "com.atproto.server.getAccountInviteCodes",

     

       41
       41
       +
           "lexicon" => 1

     

       42
       42
       +
         })

     

       43
       43
       +
       end

+52

lib/atproto/com/atproto/server/getServiceAuth.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.GetServiceAuth do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get a signed token on behalf of the requesting DID for the requested service.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{

     

       11
       11
       +
                   "description" =>

     

       12
       12
       +
                     "Indicates that the requested expiration date is not a valid. May be in the past or may be reliant on the requested scopes.",

     

       13
       13
       +
                   "name" => "BadExpiration"

     

       14
       14
       +
                 }

     

       15
       15
       +
               ],

     

       16
       16
       +
               "output" => %{

     

       17
       17
       +
                 "encoding" => "application/json",

     

       18
       18
       +
                 "schema" => %{

     

       19
       19
       +
                   "properties" => %{"token" => %{"type" => "string"}},

     

       20
       20
       +
                   "required" => ["token"],

     

       21
       21
       +
                   "type" => "object"

     

       22
       22
       +
                 }

     

       23
       23
       +
               },

     

       24
       24
       +
               "parameters" => %{

     

       25
       25
       +
                 "properties" => %{

     

       26
       26
       +
                   "aud" => %{

     

       27
       27
       +
                     "description" =>

     

       28
       28
       +
                       "The DID of the service that the token will be used to authenticate with",

     

       29
       29
       +
                     "format" => "did",

     

       30
       30
       +
                     "type" => "string"

     

       31
       31
       +
                   },

     

       32
       32
       +
                   "exp" => %{

     

       33
       33
       +
                     "description" =>

     

       34
       34
       +
                       "The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope.",

     

       35
       35
       +
                     "type" => "integer"

     

       36
       36
       +
                   },

     

       37
       37
       +
                   "lxm" => %{

     

       38
       38
       +
                     "description" => "Lexicon (XRPC) method to bind the requested token to",

     

       39
       39
       +
                     "format" => "nsid",

     

       40
       40
       +
                     "type" => "string"

     

       41
       41
       +
                   }

     

       42
       42
       +
                 },

     

       43
       43
       +
                 "required" => ["aud"],

     

       44
       44
       +
                 "type" => "params"

     

       45
       45
       +
               },

     

       46
       46
       +
               "type" => "query"

     

       47
       47
       +
             }

     

       48
       48
       +
           },

     

       49
       49
       +
           "id" => "com.atproto.server.getServiceAuth",

     

       50
       50
       +
           "lexicon" => 1

     

       51
       51
       +
         })

     

       52
       52
       +
       end

+36

lib/atproto/com/atproto/server/getSession.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.GetSession do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Get information about the current auth session. Requires auth.",

     

       8
       8
       +
               "output" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{

     

       12
       12
       +
                     "active" => %{"type" => "boolean"},

     

       13
       13
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       14
       14
       +
                     "didDoc" => %{"type" => "unknown"},

     

       15
       15
       +
                     "email" => %{"type" => "string"},

     

       16
       16
       +
                     "emailAuthFactor" => %{"type" => "boolean"},

     

       17
       17
       +
                     "emailConfirmed" => %{"type" => "boolean"},

     

       18
       18
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       19
       19
       +
                     "status" => %{

     

       20
       20
       +
                       "description" =>

     

       21
       21
       +
                         "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",

     

       22
       22
       +
                       "knownValues" => ["takendown", "suspended", "deactivated"],

     

       23
       23
       +
                       "type" => "string"

     

       24
       24
       +
                     }

     

       25
       25
       +
                   },

     

       26
       26
       +
                   "required" => ["handle", "did"],

     

       27
       27
       +
                   "type" => "object"

     

       28
       28
       +
                 }

     

       29
       29
       +
               },

     

       30
       30
       +
               "type" => "query"

     

       31
       31
       +
             }

     

       32
       32
       +
           },

     

       33
       33
       +
           "id" => "com.atproto.server.getSession",

     

       34
       34
       +
           "lexicon" => 1

     

       35
       35
       +
         })

     

       36
       36
       +
       end

+37

lib/atproto/com/atproto/server/listAppPasswords.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.ListAppPasswords do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "appPassword" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "createdAt" => %{"format" => "datetime", "type" => "string"},

     

       9
       9
       +
                 "name" => %{"type" => "string"},

     

       10
       10
       +
                 "privileged" => %{"type" => "boolean"}

     

       11
       11
       +
               },

     

       12
       12
       +
               "required" => ["name", "createdAt"],

     

       13
       13
       +
               "type" => "object"

     

       14
       14
       +
             },

     

       15
       15
       +
             "main" => %{

     

       16
       16
       +
               "description" => "List all App Passwords.",

     

       17
       17
       +
               "errors" => [%{"name" => "AccountTakedown"}],

     

       18
       18
       +
               "output" => %{

     

       19
       19
       +
                 "encoding" => "application/json",

     

       20
       20
       +
                 "schema" => %{

     

       21
       21
       +
                   "properties" => %{

     

       22
       22
       +
                     "passwords" => %{

     

       23
       23
       +
                       "items" => %{"ref" => "#appPassword", "type" => "ref"},

     

       24
       24
       +
                       "type" => "array"

     

       25
       25
       +
                     }

     

       26
       26
       +
                   },

     

       27
       27
       +
                   "required" => ["passwords"],

     

       28
       28
       +
                   "type" => "object"

     

       29
       29
       +
                 }

     

       30
       30
       +
               },

     

       31
       31
       +
               "type" => "query"

     

       32
       32
       +
             }

     

       33
       33
       +
           },

     

       34
       34
       +
           "id" => "com.atproto.server.listAppPasswords",

     

       35
       35
       +
           "lexicon" => 1

     

       36
       36
       +
         })

     

       37
       37
       +
       end

+37

lib/atproto/com/atproto/server/refreshSession.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.RefreshSession do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Refresh an authentication session. Requires auth using the 'refreshJwt' (not the 'accessJwt').",

     

       9
       9
       +
               "errors" => [%{"name" => "AccountTakedown"}],

     

       10
       10
       +
               "output" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "properties" => %{

     

       14
       14
       +
                     "accessJwt" => %{"type" => "string"},

     

       15
       15
       +
                     "active" => %{"type" => "boolean"},

     

       16
       16
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       17
       17
       +
                     "didDoc" => %{"type" => "unknown"},

     

       18
       18
       +
                     "handle" => %{"format" => "handle", "type" => "string"},

     

       19
       19
       +
                     "refreshJwt" => %{"type" => "string"},

     

       20
       20
       +
                     "status" => %{

     

       21
       21
       +
                       "description" =>

     

       22
       22
       +
                         "Hosting status of the account. If not specified, then assume 'active'.",

     

       23
       23
       +
                       "knownValues" => ["takendown", "suspended", "deactivated"],

     

       24
       24
       +
                       "type" => "string"

     

       25
       25
       +
                     }

     

       26
       26
       +
                   },

     

       27
       27
       +
                   "required" => ["accessJwt", "refreshJwt", "handle", "did"],

     

       28
       28
       +
                   "type" => "object"

     

       29
       29
       +
                 }

     

       30
       30
       +
               },

     

       31
       31
       +
               "type" => "procedure"

     

       32
       32
       +
             }

     

       33
       33
       +
           },

     

       34
       34
       +
           "id" => "com.atproto.server.refreshSession",

     

       35
       35
       +
           "lexicon" => 1

     

       36
       36
       +
         })

     

       37
       37
       +
       end

+14

lib/atproto/com/atproto/server/requestAccountDelete.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.RequestAccountDelete do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Initiate a user account deletion via email.",

     

       8
       8
       +
               "type" => "procedure"

     

       9
       9
       +
             }

     

       10
       10
       +
           },

     

       11
       11
       +
           "id" => "com.atproto.server.requestAccountDelete",

     

       12
       12
       +
           "lexicon" => 1

     

       13
       13
       +
         })

     

       14
       14
       +
       end

+14

lib/atproto/com/atproto/server/requestEmailConfirmation.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.RequestEmailConfirmation do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Request an email with a code to confirm ownership of email.",

     

       8
       8
       +
               "type" => "procedure"

     

       9
       9
       +
             }

     

       10
       10
       +
           },

     

       11
       11
       +
           "id" => "com.atproto.server.requestEmailConfirmation",

     

       12
       12
       +
           "lexicon" => 1

     

       13
       13
       +
         })

     

       14
       14
       +
       end

+22

lib/atproto/com/atproto/server/requestEmailUpdate.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.RequestEmailUpdate do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Request a token in order to update email.",

     

       8
       8
       +
               "output" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{"tokenRequired" => %{"type" => "boolean"}},

     

       12
       12
       +
                   "required" => ["tokenRequired"],

     

       13
       13
       +
                   "type" => "object"

     

       14
       14
       +
                 }

     

       15
       15
       +
               },

     

       16
       16
       +
               "type" => "procedure"

     

       17
       17
       +
             }

     

       18
       18
       +
           },

     

       19
       19
       +
           "id" => "com.atproto.server.requestEmailUpdate",

     

       20
       20
       +
           "lexicon" => 1

     

       21
       21
       +
         })

     

       22
       22
       +
       end

+22

lib/atproto/com/atproto/server/requestPasswordReset.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.RequestPasswordReset do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Initiate a user account password reset via email.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{"email" => %{"type" => "string"}},

     

       12
       12
       +
                   "required" => ["email"],

     

       13
       13
       +
                   "type" => "object"

     

       14
       14
       +
                 }

     

       15
       15
       +
               },

     

       16
       16
       +
               "type" => "procedure"

     

       17
       17
       +
             }

     

       18
       18
       +
           },

     

       19
       19
       +
           "id" => "com.atproto.server.requestPasswordReset",

     

       20
       20
       +
           "lexicon" => 1

     

       21
       21
       +
         })

     

       22
       22
       +
       end

+42

lib/atproto/com/atproto/server/reserveSigningKey.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.ReserveSigningKey do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Reserve a repo signing key, for use with account creation. Necessary so that a DID PLC update operation can be constructed during an account migraiton. Public and does not require auth; implemented by PDS. NOTE: this endpoint may change when full account migration is implemented.",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "did" => %{

     

       14
       14
       +
                       "description" => "The DID to reserve a key for.",

     

       15
       15
       +
                       "format" => "did",

     

       16
       16
       +
                       "type" => "string"

     

       17
       17
       +
                     }

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "type" => "object"

     

       20
       20
       +
                 }

     

       21
       21
       +
               },

     

       22
       22
       +
               "output" => %{

     

       23
       23
       +
                 "encoding" => "application/json",

     

       24
       24
       +
                 "schema" => %{

     

       25
       25
       +
                   "properties" => %{

     

       26
       26
       +
                     "signingKey" => %{

     

       27
       27
       +
                       "description" =>

     

       28
       28
       +
                         "The public key for the reserved signing key, in did:key serialization.",

     

       29
       29
       +
                       "type" => "string"

     

       30
       30
       +
                     }

     

       31
       31
       +
                   },

     

       32
       32
       +
                   "required" => ["signingKey"],

     

       33
       33
       +
                   "type" => "object"

     

       34
       34
       +
                 }

     

       35
       35
       +
               },

     

       36
       36
       +
               "type" => "procedure"

     

       37
       37
       +
             }

     

       38
       38
       +
           },

     

       39
       39
       +
           "id" => "com.atproto.server.reserveSigningKey",

     

       40
       40
       +
           "lexicon" => 1

     

       41
       41
       +
         })

     

       42
       42
       +
       end

+26

lib/atproto/com/atproto/server/resetPassword.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.ResetPassword do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Reset a user account password using a token.",

     

       8
       8
       +
               "errors" => [%{"name" => "ExpiredToken"}, %{"name" => "InvalidToken"}],

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "password" => %{"type" => "string"},

     

       14
       14
       +
                     "token" => %{"type" => "string"}

     

       15
       15
       +
                   },

     

       16
       16
       +
                   "required" => ["token", "password"],

     

       17
       17
       +
                   "type" => "object"

     

       18
       18
       +
                 }

     

       19
       19
       +
               },

     

       20
       20
       +
               "type" => "procedure"

     

       21
       21
       +
             }

     

       22
       22
       +
           },

     

       23
       23
       +
           "id" => "com.atproto.server.resetPassword",

     

       24
       24
       +
           "lexicon" => 1

     

       25
       25
       +
         })

     

       26
       26
       +
       end

+22

lib/atproto/com/atproto/server/revokeAppPassword.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.RevokeAppPassword do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Revoke an App Password by name.",

     

       8
       8
       +
               "input" => %{

     

       9
       9
       +
                 "encoding" => "application/json",

     

       10
       10
       +
                 "schema" => %{

     

       11
       11
       +
                   "properties" => %{"name" => %{"type" => "string"}},

     

       12
       12
       +
                   "required" => ["name"],

     

       13
       13
       +
                   "type" => "object"

     

       14
       14
       +
                 }

     

       15
       15
       +
               },

     

       16
       16
       +
               "type" => "procedure"

     

       17
       17
       +
             }

     

       18
       18
       +
           },

     

       19
       19
       +
           "id" => "com.atproto.server.revokeAppPassword",

     

       20
       20
       +
           "lexicon" => 1

     

       21
       21
       +
         })

     

       22
       22
       +
       end

+35

lib/atproto/com/atproto/server/updateEmail.ex

···

       1
       1
       +
       defmodule Com.Atproto.Server.UpdateEmail do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "Update an account's email.",

     

       8
       8
       +
               "errors" => [

     

       9
       9
       +
                 %{"name" => "ExpiredToken"},

     

       10
       10
       +
                 %{"name" => "InvalidToken"},

     

       11
       11
       +
                 %{"name" => "TokenRequired"}

     

       12
       12
       +
               ],

     

       13
       13
       +
               "input" => %{

     

       14
       14
       +
                 "encoding" => "application/json",

     

       15
       15
       +
                 "schema" => %{

     

       16
       16
       +
                   "properties" => %{

     

       17
       17
       +
                     "email" => %{"type" => "string"},

     

       18
       18
       +
                     "emailAuthFactor" => %{"type" => "boolean"},

     

       19
       19
       +
                     "token" => %{

     

       20
       20
       +
                       "description" =>

     

       21
       21
       +
                         "Requires a token from com.atproto.sever.requestEmailUpdate if the account's email has been confirmed.",

     

       22
       22
       +
                       "type" => "string"

     

       23
       23
       +
                     }

     

       24
       24
       +
                   },

     

       25
       25
       +
                   "required" => ["email"],

     

       26
       26
       +
                   "type" => "object"

     

       27
       27
       +
                 }

     

       28
       28
       +
               },

     

       29
       29
       +
               "type" => "procedure"

     

       30
       30
       +
             }

     

       31
       31
       +
           },

     

       32
       32
       +
           "id" => "com.atproto.server.updateEmail",

     

       33
       33
       +
           "lexicon" => 1

     

       34
       34
       +
         })

     

       35
       35
       +
       end

+14

lib/atproto/com/atproto/sync/defs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.Defs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "hostStatus" => %{

     

       7
       7
       +
               "knownValues" => ["active", "idle", "offline", "throttled", "banned"],

     

       8
       8
       +
               "type" => "string"

     

       9
       9
       +
             }

     

       10
       10
       +
           },

     

       11
       11
       +
           "id" => "com.atproto.sync.defs",

     

       12
       12
       +
           "lexicon" => 1

     

       13
       13
       +
         })

     

       14
       14
       +
       end

+39

lib/atproto/com/atproto/sync/getBlob.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetBlob do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get a blob associated with a given account. Returns the full blob as originally uploaded. Does not require auth; implemented by PDS.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{"name" => "BlobNotFound"},

     

       11
       11
       +
                 %{"name" => "RepoNotFound"},

     

       12
       12
       +
                 %{"name" => "RepoTakendown"},

     

       13
       13
       +
                 %{"name" => "RepoSuspended"},

     

       14
       14
       +
                 %{"name" => "RepoDeactivated"}

     

       15
       15
       +
               ],

     

       16
       16
       +
               "output" => %{"encoding" => "*/*"},

     

       17
       17
       +
               "parameters" => %{

     

       18
       18
       +
                 "properties" => %{

     

       19
       19
       +
                   "cid" => %{

     

       20
       20
       +
                     "description" => "The CID of the blob to fetch",

     

       21
       21
       +
                     "format" => "cid",

     

       22
       22
       +
                     "type" => "string"

     

       23
       23
       +
                   },

     

       24
       24
       +
                   "did" => %{

     

       25
       25
       +
                     "description" => "The DID of the account.",

     

       26
       26
       +
                     "format" => "did",

     

       27
       27
       +
                     "type" => "string"

     

       28
       28
       +
                   }

     

       29
       29
       +
                 },

     

       30
       30
       +
                 "required" => ["did", "cid"],

     

       31
       31
       +
                 "type" => "params"

     

       32
       32
       +
               },

     

       33
       33
       +
               "type" => "query"

     

       34
       34
       +
             }

     

       35
       35
       +
           },

     

       36
       36
       +
           "id" => "com.atproto.sync.getBlob",

     

       37
       37
       +
           "lexicon" => 1

     

       38
       38
       +
         })

     

       39
       39
       +
       end

+38

lib/atproto/com/atproto/sync/getBlocks.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetBlocks do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get data blocks from a given repo, by CID. For example, intermediate MST nodes, or records. Does not require auth; implemented by PDS.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{"name" => "BlockNotFound"},

     

       11
       11
       +
                 %{"name" => "RepoNotFound"},

     

       12
       12
       +
                 %{"name" => "RepoTakendown"},

     

       13
       13
       +
                 %{"name" => "RepoSuspended"},

     

       14
       14
       +
                 %{"name" => "RepoDeactivated"}

     

       15
       15
       +
               ],

     

       16
       16
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       17
       17
       +
               "parameters" => %{

     

       18
       18
       +
                 "properties" => %{

     

       19
       19
       +
                   "cids" => %{

     

       20
       20
       +
                     "items" => %{"format" => "cid", "type" => "string"},

     

       21
       21
       +
                     "type" => "array"

     

       22
       22
       +
                   },

     

       23
       23
       +
                   "did" => %{

     

       24
       24
       +
                     "description" => "The DID of the repo.",

     

       25
       25
       +
                     "format" => "did",

     

       26
       26
       +
                     "type" => "string"

     

       27
       27
       +
                   }

     

       28
       28
       +
                 },

     

       29
       29
       +
                 "required" => ["did", "cids"],

     

       30
       30
       +
                 "type" => "params"

     

       31
       31
       +
               },

     

       32
       32
       +
               "type" => "query"

     

       33
       33
       +
             }

     

       34
       34
       +
           },

     

       35
       35
       +
           "id" => "com.atproto.sync.getBlocks",

     

       36
       36
       +
           "lexicon" => 1

     

       37
       37
       +
         })

     

       38
       38
       +
       end

+26

lib/atproto/com/atproto/sync/getCheckout.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetCheckout do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "DEPRECATED - please use com.atproto.sync.getRepo instead",

     

       8
       8
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       9
       9
       +
               "parameters" => %{

     

       10
       10
       +
                 "properties" => %{

     

       11
       11
       +
                   "did" => %{

     

       12
       12
       +
                     "description" => "The DID of the repo.",

     

       13
       13
       +
                     "format" => "did",

     

       14
       14
       +
                     "type" => "string"

     

       15
       15
       +
                   }

     

       16
       16
       +
                 },

     

       17
       17
       +
                 "required" => ["did"],

     

       18
       18
       +
                 "type" => "params"

     

       19
       19
       +
               },

     

       20
       20
       +
               "type" => "query"

     

       21
       21
       +
             }

     

       22
       22
       +
           },

     

       23
       23
       +
           "id" => "com.atproto.sync.getCheckout",

     

       24
       24
       +
           "lexicon" => 1

     

       25
       25
       +
         })

     

       26
       26
       +
       end

+34

lib/atproto/com/atproto/sync/getHead.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetHead do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" => "DEPRECATED - please use com.atproto.sync.getLatestCommit instead",

     

       8
       8
       +
               "errors" => [%{"name" => "HeadNotFound"}],

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{"root" => %{"format" => "cid", "type" => "string"}},

     

       13
       13
       +
                   "required" => ["root"],

     

       14
       14
       +
                   "type" => "object"

     

       15
       15
       +
                 }

     

       16
       16
       +
               },

     

       17
       17
       +
               "parameters" => %{

     

       18
       18
       +
                 "properties" => %{

     

       19
       19
       +
                   "did" => %{

     

       20
       20
       +
                     "description" => "The DID of the repo.",

     

       21
       21
       +
                     "format" => "did",

     

       22
       22
       +
                     "type" => "string"

     

       23
       23
       +
                   }

     

       24
       24
       +
                 },

     

       25
       25
       +
                 "required" => ["did"],

     

       26
       26
       +
                 "type" => "params"

     

       27
       27
       +
               },

     

       28
       28
       +
               "type" => "query"

     

       29
       29
       +
             }

     

       30
       30
       +
           },

     

       31
       31
       +
           "id" => "com.atproto.sync.getHead",

     

       32
       32
       +
           "lexicon" => 1

     

       33
       33
       +
         })

     

       34
       34
       +
       end

+50

lib/atproto/com/atproto/sync/getHostStatus.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetHostStatus do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Returns information about a specified upstream host, as consumed by the server. Implemented by relays.",

     

       9
       9
       +
               "errors" => [%{"name" => "HostNotFound"}],

     

       10
       10
       +
               "output" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "properties" => %{

     

       14
       14
       +
                     "accountCount" => %{

     

       15
       15
       +
                       "description" =>

     

       16
       16
       +
                         "Number of accounts on the server which are associated with the upstream host. Note that the upstream may actually have more accounts.",

     

       17
       17
       +
                       "type" => "integer"

     

       18
       18
       +
                     },

     

       19
       19
       +
                     "hostname" => %{"type" => "string"},

     

       20
       20
       +
                     "seq" => %{

     

       21
       21
       +
                       "description" =>

     

       22
       22
       +
                         "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).",

     

       23
       23
       +
                       "type" => "integer"

     

       24
       24
       +
                     },

     

       25
       25
       +
                     "status" => %{

     

       26
       26
       +
                       "ref" => "com.atproto.sync.defs#hostStatus",

     

       27
       27
       +
                       "type" => "ref"

     

       28
       28
       +
                     }

     

       29
       29
       +
                   },

     

       30
       30
       +
                   "required" => ["hostname"],

     

       31
       31
       +
                   "type" => "object"

     

       32
       32
       +
                 }

     

       33
       33
       +
               },

     

       34
       34
       +
               "parameters" => %{

     

       35
       35
       +
                 "properties" => %{

     

       36
       36
       +
                   "hostname" => %{

     

       37
       37
       +
                     "description" => "Hostname of the host (eg, PDS or relay) being queried.",

     

       38
       38
       +
                     "type" => "string"

     

       39
       39
       +
                   }

     

       40
       40
       +
                 },

     

       41
       41
       +
                 "required" => ["hostname"],

     

       42
       42
       +
                 "type" => "params"

     

       43
       43
       +
               },

     

       44
       44
       +
               "type" => "query"

     

       45
       45
       +
             }

     

       46
       46
       +
           },

     

       47
       47
       +
           "id" => "com.atproto.sync.getHostStatus",

     

       48
       48
       +
           "lexicon" => 1

     

       49
       49
       +
         })

     

       50
       50
       +
       end

+43

lib/atproto/com/atproto/sync/getLatestCommit.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetLatestCommit do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get the current commit CID & revision of the specified repo. Does not require auth.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{"name" => "RepoNotFound"},

     

       11
       11
       +
                 %{"name" => "RepoTakendown"},

     

       12
       12
       +
                 %{"name" => "RepoSuspended"},

     

       13
       13
       +
                 %{"name" => "RepoDeactivated"}

     

       14
       14
       +
               ],

     

       15
       15
       +
               "output" => %{

     

       16
       16
       +
                 "encoding" => "application/json",

     

       17
       17
       +
                 "schema" => %{

     

       18
       18
       +
                   "properties" => %{

     

       19
       19
       +
                     "cid" => %{"format" => "cid", "type" => "string"},

     

       20
       20
       +
                     "rev" => %{"format" => "tid", "type" => "string"}

     

       21
       21
       +
                   },

     

       22
       22
       +
                   "required" => ["cid", "rev"],

     

       23
       23
       +
                   "type" => "object"

     

       24
       24
       +
                 }

     

       25
       25
       +
               },

     

       26
       26
       +
               "parameters" => %{

     

       27
       27
       +
                 "properties" => %{

     

       28
       28
       +
                   "did" => %{

     

       29
       29
       +
                     "description" => "The DID of the repo.",

     

       30
       30
       +
                     "format" => "did",

     

       31
       31
       +
                     "type" => "string"

     

       32
       32
       +
                   }

     

       33
       33
       +
                 },

     

       34
       34
       +
                 "required" => ["did"],

     

       35
       35
       +
                 "type" => "params"

     

       36
       36
       +
               },

     

       37
       37
       +
               "type" => "query"

     

       38
       38
       +
             }

     

       39
       39
       +
           },

     

       40
       40
       +
           "id" => "com.atproto.sync.getLatestCommit",

     

       41
       41
       +
           "lexicon" => 1

     

       42
       42
       +
         })

     

       43
       43
       +
       end

+40

lib/atproto/com/atproto/sync/getRecord.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetRecord do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get data blocks needed to prove the existence or non-existence of record in the current version of repo. Does not require auth.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{"name" => "RecordNotFound"},

     

       11
       11
       +
                 %{"name" => "RepoNotFound"},

     

       12
       12
       +
                 %{"name" => "RepoTakendown"},

     

       13
       13
       +
                 %{"name" => "RepoSuspended"},

     

       14
       14
       +
                 %{"name" => "RepoDeactivated"}

     

       15
       15
       +
               ],

     

       16
       16
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       17
       17
       +
               "parameters" => %{

     

       18
       18
       +
                 "properties" => %{

     

       19
       19
       +
                   "collection" => %{"format" => "nsid", "type" => "string"},

     

       20
       20
       +
                   "did" => %{

     

       21
       21
       +
                     "description" => "The DID of the repo.",

     

       22
       22
       +
                     "format" => "did",

     

       23
       23
       +
                     "type" => "string"

     

       24
       24
       +
                   },

     

       25
       25
       +
                   "rkey" => %{

     

       26
       26
       +
                     "description" => "Record Key",

     

       27
       27
       +
                     "format" => "record-key",

     

       28
       28
       +
                     "type" => "string"

     

       29
       29
       +
                   }

     

       30
       30
       +
                 },

     

       31
       31
       +
                 "required" => ["did", "collection", "rkey"],

     

       32
       32
       +
                 "type" => "params"

     

       33
       33
       +
               },

     

       34
       34
       +
               "type" => "query"

     

       35
       35
       +
             }

     

       36
       36
       +
           },

     

       37
       37
       +
           "id" => "com.atproto.sync.getRecord",

     

       38
       38
       +
           "lexicon" => 1

     

       39
       39
       +
         })

     

       40
       40
       +
       end

+38

lib/atproto/com/atproto/sync/getRepo.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetRepo do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Download a repository export as CAR file. Optionally only a 'diff' since a previous revision. Does not require auth; implemented by PDS.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{"name" => "RepoNotFound"},

     

       11
       11
       +
                 %{"name" => "RepoTakendown"},

     

       12
       12
       +
                 %{"name" => "RepoSuspended"},

     

       13
       13
       +
                 %{"name" => "RepoDeactivated"}

     

       14
       14
       +
               ],

     

       15
       15
       +
               "output" => %{"encoding" => "application/vnd.ipld.car"},

     

       16
       16
       +
               "parameters" => %{

     

       17
       17
       +
                 "properties" => %{

     

       18
       18
       +
                   "did" => %{

     

       19
       19
       +
                     "description" => "The DID of the repo.",

     

       20
       20
       +
                     "format" => "did",

     

       21
       21
       +
                     "type" => "string"

     

       22
       22
       +
                   },

     

       23
       23
       +
                   "since" => %{

     

       24
       24
       +
                     "description" => "The revision ('rev') of the repo to create a diff from.",

     

       25
       25
       +
                     "format" => "tid",

     

       26
       26
       +
                     "type" => "string"

     

       27
       27
       +
                   }

     

       28
       28
       +
                 },

     

       29
       29
       +
                 "required" => ["did"],

     

       30
       30
       +
                 "type" => "params"

     

       31
       31
       +
               },

     

       32
       32
       +
               "type" => "query"

     

       33
       33
       +
             }

     

       34
       34
       +
           },

     

       35
       35
       +
           "id" => "com.atproto.sync.getRepo",

     

       36
       36
       +
           "lexicon" => 1

     

       37
       37
       +
         })

     

       38
       38
       +
       end

+56

lib/atproto/com/atproto/sync/getRepoStatus.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.GetRepoStatus do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Get the hosting status for a repository, on this server. Expected to be implemented by PDS and Relay.",

     

       9
       9
       +
               "errors" => [%{"name" => "RepoNotFound"}],

     

       10
       10
       +
               "output" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "properties" => %{

     

       14
       14
       +
                     "active" => %{"type" => "boolean"},

     

       15
       15
       +
                     "did" => %{"format" => "did", "type" => "string"},

     

       16
       16
       +
                     "rev" => %{

     

       17
       17
       +
                       "description" => "Optional field, the current rev of the repo, if active=true",

     

       18
       18
       +
                       "format" => "tid",

     

       19
       19
       +
                       "type" => "string"

     

       20
       20
       +
                     },

     

       21
       21
       +
                     "status" => %{

     

       22
       22
       +
                       "description" =>

     

       23
       23
       +
                         "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",

     

       24
       24
       +
                       "knownValues" => [

     

       25
       25
       +
                         "takendown",

     

       26
       26
       +
                         "suspended",

     

       27
       27
       +
                         "deleted",

     

       28
       28
       +
                         "deactivated",

     

       29
       29
       +
                         "desynchronized",

     

       30
       30
       +
                         "throttled"

     

       31
       31
       +
                       ],

     

       32
       32
       +
                       "type" => "string"

     

       33
       33
       +
                     }

     

       34
       34
       +
                   },

     

       35
       35
       +
                   "required" => ["did", "active"],

     

       36
       36
       +
                   "type" => "object"

     

       37
       37
       +
                 }

     

       38
       38
       +
               },

     

       39
       39
       +
               "parameters" => %{

     

       40
       40
       +
                 "properties" => %{

     

       41
       41
       +
                   "did" => %{

     

       42
       42
       +
                     "description" => "The DID of the repo.",

     

       43
       43
       +
                     "format" => "did",

     

       44
       44
       +
                     "type" => "string"

     

       45
       45
       +
                   }

     

       46
       46
       +
                 },

     

       47
       47
       +
                 "required" => ["did"],

     

       48
       48
       +
                 "type" => "params"

     

       49
       49
       +
               },

     

       50
       50
       +
               "type" => "query"

     

       51
       51
       +
             }

     

       52
       52
       +
           },

     

       53
       53
       +
           "id" => "com.atproto.sync.getRepoStatus",

     

       54
       54
       +
           "lexicon" => 1

     

       55
       55
       +
         })

     

       56
       56
       +
       end

+58

lib/atproto/com/atproto/sync/listBlobs.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.ListBlobs do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "List blob CIDs for an account, since some repo revision. Does not require auth; implemented by PDS.",

     

       9
       9
       +
               "errors" => [

     

       10
       10
       +
                 %{"name" => "RepoNotFound"},

     

       11
       11
       +
                 %{"name" => "RepoTakendown"},

     

       12
       12
       +
                 %{"name" => "RepoSuspended"},

     

       13
       13
       +
                 %{"name" => "RepoDeactivated"}

     

       14
       14
       +
               ],

     

       15
       15
       +
               "output" => %{

     

       16
       16
       +
                 "encoding" => "application/json",

     

       17
       17
       +
                 "schema" => %{

     

       18
       18
       +
                   "properties" => %{

     

       19
       19
       +
                     "cids" => %{

     

       20
       20
       +
                       "items" => %{"format" => "cid", "type" => "string"},

     

       21
       21
       +
                       "type" => "array"

     

       22
       22
       +
                     },

     

       23
       23
       +
                     "cursor" => %{"type" => "string"}

     

       24
       24
       +
                   },

     

       25
       25
       +
                   "required" => ["cids"],

     

       26
       26
       +
                   "type" => "object"

     

       27
       27
       +
                 }

     

       28
       28
       +
               },

     

       29
       29
       +
               "parameters" => %{

     

       30
       30
       +
                 "properties" => %{

     

       31
       31
       +
                   "cursor" => %{"type" => "string"},

     

       32
       32
       +
                   "did" => %{

     

       33
       33
       +
                     "description" => "The DID of the repo.",

     

       34
       34
       +
                     "format" => "did",

     

       35
       35
       +
                     "type" => "string"

     

       36
       36
       +
                   },

     

       37
       37
       +
                   "limit" => %{

     

       38
       38
       +
                     "default" => 500,

     

       39
       39
       +
                     "maximum" => 1000,

     

       40
       40
       +
                     "minimum" => 1,

     

       41
       41
       +
                     "type" => "integer"

     

       42
       42
       +
                   },

     

       43
       43
       +
                   "since" => %{

     

       44
       44
       +
                     "description" => "Optional revision of the repo to list blobs since.",

     

       45
       45
       +
                     "format" => "tid",

     

       46
       46
       +
                     "type" => "string"

     

       47
       47
       +
                   }

     

       48
       48
       +
                 },

     

       49
       49
       +
                 "required" => ["did"],

     

       50
       50
       +
                 "type" => "params"

     

       51
       51
       +
               },

     

       52
       52
       +
               "type" => "query"

     

       53
       53
       +
             }

     

       54
       54
       +
           },

     

       55
       55
       +
           "id" => "com.atproto.sync.listBlobs",

     

       56
       56
       +
           "lexicon" => 1

     

       57
       57
       +
         })

     

       58
       58
       +
       end

+63

lib/atproto/com/atproto/sync/listHosts.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.ListHosts do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "host" => %{

     

       7
       7
       +
               "properties" => %{

     

       8
       8
       +
                 "accountCount" => %{"type" => "integer"},

     

       9
       9
       +
                 "hostname" => %{

     

       10
       10
       +
                   "description" => "hostname of server; not a URL (no scheme)",

     

       11
       11
       +
                   "type" => "string"

     

       12
       12
       +
                 },

     

       13
       13
       +
                 "seq" => %{

     

       14
       14
       +
                   "description" =>

     

       15
       15
       +
                     "Recent repo stream event sequence number. May be delayed from actual stream processing (eg, persisted cursor not in-memory cursor).",

     

       16
       16
       +
                   "type" => "integer"

     

       17
       17
       +
                 },

     

       18
       18
       +
                 "status" => %{

     

       19
       19
       +
                   "ref" => "com.atproto.sync.defs#hostStatus",

     

       20
       20
       +
                   "type" => "ref"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "required" => ["hostname"],

     

       24
       24
       +
               "type" => "object"

     

       25
       25
       +
             },

     

       26
       26
       +
             "main" => %{

     

       27
       27
       +
               "description" =>

     

       28
       28
       +
                 "Enumerates upstream hosts (eg, PDS or relay instances) that this service consumes from. Implemented by relays.",

     

       29
       29
       +
               "output" => %{

     

       30
       30
       +
                 "encoding" => "application/json",

     

       31
       31
       +
                 "schema" => %{

     

       32
       32
       +
                   "properties" => %{

     

       33
       33
       +
                     "cursor" => %{"type" => "string"},

     

       34
       34
       +
                     "hosts" => %{

     

       35
       35
       +
                       "description" =>

     

       36
       36
       +
                         "Sort order is not formally specified. Recommended order is by time host was first seen by the server, with oldest first.",

     

       37
       37
       +
                       "items" => %{"ref" => "#host", "type" => "ref"},

     

       38
       38
       +
                       "type" => "array"

     

       39
       39
       +
                     }

     

       40
       40
       +
                   },

     

       41
       41
       +
                   "required" => ["hosts"],

     

       42
       42
       +
                   "type" => "object"

     

       43
       43
       +
                 }

     

       44
       44
       +
               },

     

       45
       45
       +
               "parameters" => %{

     

       46
       46
       +
                 "properties" => %{

     

       47
       47
       +
                   "cursor" => %{"type" => "string"},

     

       48
       48
       +
                   "limit" => %{

     

       49
       49
       +
                     "default" => 200,

     

       50
       50
       +
                     "maximum" => 1000,

     

       51
       51
       +
                     "minimum" => 1,

     

       52
       52
       +
                     "type" => "integer"

     

       53
       53
       +
                   }

     

       54
       54
       +
                 },

     

       55
       55
       +
                 "type" => "params"

     

       56
       56
       +
               },

     

       57
       57
       +
               "type" => "query"

     

       58
       58
       +
             }

     

       59
       59
       +
           },

     

       60
       60
       +
           "id" => "com.atproto.sync.listHosts",

     

       61
       61
       +
           "lexicon" => 1

     

       62
       62
       +
         })

     

       63
       63
       +
       end

+68

lib/atproto/com/atproto/sync/listRepos.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.ListRepos do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Enumerates all the DID, rev, and commit CID for all repos hosted by this service. Does not require auth; implemented by PDS and Relay.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       14
       +
                     "repos" => %{

     

       15
       15
       +
                       "items" => %{"ref" => "#repo", "type" => "ref"},

     

       16
       16
       +
                       "type" => "array"

     

       17
       17
       +
                     }

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["repos"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "parameters" => %{

     

       24
       24
       +
                 "properties" => %{

     

       25
       25
       +
                   "cursor" => %{"type" => "string"},

     

       26
       26
       +
                   "limit" => %{

     

       27
       27
       +
                     "default" => 500,

     

       28
       28
       +
                     "maximum" => 1000,

     

       29
       29
       +
                     "minimum" => 1,

     

       30
       30
       +
                     "type" => "integer"

     

       31
       31
       +
                   }

     

       32
       32
       +
                 },

     

       33
       33
       +
                 "type" => "params"

     

       34
       34
       +
               },

     

       35
       35
       +
               "type" => "query"

     

       36
       36
       +
             },

     

       37
       37
       +
             "repo" => %{

     

       38
       38
       +
               "properties" => %{

     

       39
       39
       +
                 "active" => %{"type" => "boolean"},

     

       40
       40
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       41
       41
       +
                 "head" => %{

     

       42
       42
       +
                   "description" => "Current repo commit CID",

     

       43
       43
       +
                   "format" => "cid",

     

       44
       44
       +
                   "type" => "string"

     

       45
       45
       +
                 },

     

       46
       46
       +
                 "rev" => %{"format" => "tid", "type" => "string"},

     

       47
       47
       +
                 "status" => %{

     

       48
       48
       +
                   "description" =>

     

       49
       49
       +
                     "If active=false, this optional field indicates a possible reason for why the account is not active. If active=false and no status is supplied, then the host makes no claim for why the repository is no longer being hosted.",

     

       50
       50
       +
                   "knownValues" => [

     

       51
       51
       +
                     "takendown",

     

       52
       52
       +
                     "suspended",

     

       53
       53
       +
                     "deleted",

     

       54
       54
       +
                     "deactivated",

     

       55
       55
       +
                     "desynchronized",

     

       56
       56
       +
                     "throttled"

     

       57
       57
       +
                   ],

     

       58
       58
       +
                   "type" => "string"

     

       59
       59
       +
                 }

     

       60
       60
       +
               },

     

       61
       61
       +
               "required" => ["did", "head", "rev"],

     

       62
       62
       +
               "type" => "object"

     

       63
       63
       +
             }

     

       64
       64
       +
           },

     

       65
       65
       +
           "id" => "com.atproto.sync.listRepos",

     

       66
       66
       +
           "lexicon" => 1

     

       67
       67
       +
         })

     

       68
       68
       +
       end

+50

lib/atproto/com/atproto/sync/listReposByCollection.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.ListReposByCollection do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Enumerates all the DIDs which have records with the given collection NSID.",

     

       9
       9
       +
               "output" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "cursor" => %{"type" => "string"},

     

       14
       14
       +
                     "repos" => %{

     

       15
       15
       +
                       "items" => %{"ref" => "#repo", "type" => "ref"},

     

       16
       16
       +
                       "type" => "array"

     

       17
       17
       +
                     }

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["repos"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "parameters" => %{

     

       24
       24
       +
                 "properties" => %{

     

       25
       25
       +
                   "collection" => %{"format" => "nsid", "type" => "string"},

     

       26
       26
       +
                   "cursor" => %{"type" => "string"},

     

       27
       27
       +
                   "limit" => %{

     

       28
       28
       +
                     "default" => 500,

     

       29
       29
       +
                     "description" =>

     

       30
       30
       +
                       "Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists.",

     

       31
       31
       +
                     "maximum" => 2000,

     

       32
       32
       +
                     "minimum" => 1,

     

       33
       33
       +
                     "type" => "integer"

     

       34
       34
       +
                   }

     

       35
       35
       +
                 },

     

       36
       36
       +
                 "required" => ["collection"],

     

       37
       37
       +
                 "type" => "params"

     

       38
       38
       +
               },

     

       39
       39
       +
               "type" => "query"

     

       40
       40
       +
             },

     

       41
       41
       +
             "repo" => %{

     

       42
       42
       +
               "properties" => %{"did" => %{"format" => "did", "type" => "string"}},

     

       43
       43
       +
               "required" => ["did"],

     

       44
       44
       +
               "type" => "object"

     

       45
       45
       +
             }

     

       46
       46
       +
           },

     

       47
       47
       +
           "id" => "com.atproto.sync.listReposByCollection",

     

       48
       48
       +
           "lexicon" => 1

     

       49
       49
       +
         })

     

       50
       50
       +
       end

+29

lib/atproto/com/atproto/sync/notifyOfUpdate.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.NotifyOfUpdate do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Notify a crawling service of a recent update, and that crawling should resume. Intended use is after a gap between repo stream events caused the crawling service to disconnect. Does not require auth; implemented by Relay. DEPRECATED: just use com.atproto.sync.requestCrawl",

     

       9
       9
       +
               "input" => %{

     

       10
       10
       +
                 "encoding" => "application/json",

     

       11
       11
       +
                 "schema" => %{

     

       12
       12
       +
                   "properties" => %{

     

       13
       13
       +
                     "hostname" => %{

     

       14
       14
       +
                       "description" =>

     

       15
       15
       +
                         "Hostname of the current service (usually a PDS) that is notifying of update.",

     

       16
       16
       +
                       "type" => "string"

     

       17
       17
       +
                     }

     

       18
       18
       +
                   },

     

       19
       19
       +
                   "required" => ["hostname"],

     

       20
       20
       +
                   "type" => "object"

     

       21
       21
       +
                 }

     

       22
       22
       +
               },

     

       23
       23
       +
               "type" => "procedure"

     

       24
       24
       +
             }

     

       25
       25
       +
           },

     

       26
       26
       +
           "id" => "com.atproto.sync.notifyOfUpdate",

     

       27
       27
       +
           "lexicon" => 1

     

       28
       28
       +
         })

     

       29
       29
       +
       end

+30

lib/atproto/com/atproto/sync/requestCrawl.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.RequestCrawl do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "main" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Request a service to persistently crawl hosted repos. Expected use is new PDS instances declaring their existence to Relays. Does not require auth.",

     

       9
       9
       +
               "errors" => [%{"name" => "HostBanned"}],

     

       10
       10
       +
               "input" => %{

     

       11
       11
       +
                 "encoding" => "application/json",

     

       12
       12
       +
                 "schema" => %{

     

       13
       13
       +
                   "properties" => %{

     

       14
       14
       +
                     "hostname" => %{

     

       15
       15
       +
                       "description" =>

     

       16
       16
       +
                         "Hostname of the current service (eg, PDS) that is requesting to be crawled.",

     

       17
       17
       +
                       "type" => "string"

     

       18
       18
       +
                     }

     

       19
       19
       +
                   },

     

       20
       20
       +
                   "required" => ["hostname"],

     

       21
       21
       +
                   "type" => "object"

     

       22
       22
       +
                 }

     

       23
       23
       +
               },

     

       24
       24
       +
               "type" => "procedure"

     

       25
       25
       +
             }

     

       26
       26
       +
           },

     

       27
       27
       +
           "id" => "com.atproto.sync.requestCrawl",

     

       28
       28
       +
           "lexicon" => 1

     

       29
       29
       +
         })

     

       30
       30
       +
       end

+237

lib/atproto/com/atproto/sync/subscribeRepos.ex

···

       1
       1
       +
       defmodule Com.Atproto.Sync.SubscribeRepos do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(%{

     

       5
       5
       +
           "defs" => %{

     

       6
       6
       +
             "account" => %{

     

       7
       7
       +
               "description" =>

     

       8
       8
       +
                 "Represents a change to an account's status on a host (eg, PDS or Relay). The semantics of this event are that the status is at the host which emitted the event, not necessarily that at the currently active PDS. Eg, a Relay takedown would emit a takedown with active=false, even if the PDS is still active.",

     

       9
       9
       +
               "properties" => %{

     

       10
       10
       +
                 "active" => %{

     

       11
       11
       +
                   "description" =>

     

       12
       12
       +
                     "Indicates that the account has a repository which can be fetched from the host that emitted this event.",

     

       13
       13
       +
                   "type" => "boolean"

     

       14
       14
       +
                 },

     

       15
       15
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       16
       16
       +
                 "seq" => %{"type" => "integer"},

     

       17
       17
       +
                 "status" => %{

     

       18
       18
       +
                   "description" =>

     

       19
       19
       +
                     "If active=false, this optional field indicates a reason for why the account is not active.",

     

       20
       20
       +
                   "knownValues" => [

     

       21
       21
       +
                     "takendown",

     

       22
       22
       +
                     "suspended",

     

       23
       23
       +
                     "deleted",

     

       24
       24
       +
                     "deactivated",

     

       25
       25
       +
                     "desynchronized",

     

       26
       26
       +
                     "throttled"

     

       27
       27
       +
                   ],

     

       28
       28
       +
                   "type" => "string"

     

       29
       29
       +
                 },

     

       30
       30
       +
                 "time" => %{"format" => "datetime", "type" => "string"}

     

       31
       31
       +
               },

     

       32
       32
       +
               "required" => ["seq", "did", "time", "active"],

     

       33
       33
       +
               "type" => "object"

     

       34
       34
       +
             },

     

       35
       35
       +
             "commit" => %{

     

       36
       36
       +
               "description" =>

     

       37
       37
       +
                 "Represents an update of repository state. Note that empty commits are allowed, which include no repo data changes, but an update to rev and signature.",

     

       38
       38
       +
               "nullable" => ["since"],

     

       39
       39
       +
               "properties" => %{

     

       40
       40
       +
                 "blobs" => %{

     

       41
       41
       +
                   "items" => %{

     

       42
       42
       +
                     "description" =>

     

       43
       43
       +
                       "DEPRECATED -- will soon always be empty. List of new blobs (by CID) referenced by records in this commit.",

     

       44
       44
       +
                     "type" => "cid-link"

     

       45
       45
       +
                   },

     

       46
       46
       +
                   "type" => "array"

     

       47
       47
       +
                 },

     

       48
       48
       +
                 "blocks" => %{

     

       49
       49
       +
                   "description" =>

     

       50
       50
       +
                     "CAR file containing relevant blocks, as a diff since the previous repo state. The commit must be included as a block, and the commit block CID must be the first entry in the CAR header 'roots' list.",

     

       51
       51
       +
                   "maxLength" => 2_000_000,

     

       52
       52
       +
                   "type" => "bytes"

     

       53
       53
       +
                 },

     

       54
       54
       +
                 "commit" => %{

     

       55
       55
       +
                   "description" => "Repo commit object CID.",

     

       56
       56
       +
                   "type" => "cid-link"

     

       57
       57
       +
                 },

     

       58
       58
       +
                 "ops" => %{

     

       59
       59
       +
                   "items" => %{

     

       60
       60
       +
                     "description" =>

     

       61
       61
       +
                       "List of repo mutation operations in this commit (eg, records created, updated, or deleted).",

     

       62
       62
       +
                     "ref" => "#repoOp",

     

       63
       63
       +
                     "type" => "ref"

     

       64
       64
       +
                   },

     

       65
       65
       +
                   "maxLength" => 200,

     

       66
       66
       +
                   "type" => "array"

     

       67
       67
       +
                 },

     

       68
       68
       +
                 "prevData" => %{

     

       69
       69
       +
                   "description" =>

     

       70
       70
       +
                     "The root CID of the MST tree for the previous commit from this repo (indicated by the 'since' revision field in this message). Corresponds to the 'data' field in the repo commit object. NOTE: this field is effectively required for the 'inductive' version of firehose.",

     

       71
       71
       +
                   "type" => "cid-link"

     

       72
       72
       +
                 },

     

       73
       73
       +
                 "rebase" => %{

     

       74
       74
       +
                   "description" => "DEPRECATED -- unused",

     

       75
       75
       +
                   "type" => "boolean"

     

       76
       76
       +
                 },

     

       77
       77
       +
                 "repo" => %{

     

       78
       78
       +
                   "description" =>

     

       79
       79
       +
                     "The repo this event comes from. Note that all other message types name this field 'did'.",

     

       80
       80
       +
                   "format" => "did",

     

       81
       81
       +
                   "type" => "string"

     

       82
       82
       +
                 },

     

       83
       83
       +
                 "rev" => %{

     

       84
       84
       +
                   "description" =>

     

       85
       85
       +
                     "The rev of the emitted commit. Note that this information is also in the commit object included in blocks, unless this is a tooBig event.",

     

       86
       86
       +
                   "format" => "tid",

     

       87
       87
       +
                   "type" => "string"

     

       88
       88
       +
                 },

     

       89
       89
       +
                 "seq" => %{

     

       90
       90
       +
                   "description" => "The stream sequence number of this message.",

     

       91
       91
       +
                   "type" => "integer"

     

       92
       92
       +
                 },

     

       93
       93
       +
                 "since" => %{

     

       94
       94
       +
                   "description" => "The rev of the last emitted commit from this repo (if any).",

     

       95
       95
       +
                   "format" => "tid",

     

       96
       96
       +
                   "type" => "string"

     

       97
       97
       +
                 },

     

       98
       98
       +
                 "time" => %{

     

       99
       99
       +
                   "description" => "Timestamp of when this message was originally broadcast.",

     

       100
       100
       +
                   "format" => "datetime",

     

       101
       101
       +
                   "type" => "string"

     

       102
       102
       +
                 },

     

       103
       103
       +
                 "tooBig" => %{

     

       104
       104
       +
                   "description" =>

     

       105
       105
       +
                     "DEPRECATED -- replaced by #sync event and data limits. Indicates that this commit contained too many ops, or data size was too large. Consumers will need to make a separate request to get missing data.",

     

       106
       106
       +
                   "type" => "boolean"

     

       107
       107
       +
                 }

     

       108
       108
       +
               },

     

       109
       109
       +
               "required" => [

     

       110
       110
       +
                 "seq",

     

       111
       111
       +
                 "rebase",

     

       112
       112
       +
                 "tooBig",

     

       113
       113
       +
                 "repo",

     

       114
       114
       +
                 "commit",

     

       115
       115
       +
                 "rev",

     

       116
       116
       +
                 "since",

     

       117
       117
       +
                 "blocks",

     

       118
       118
       +
                 "ops",

     

       119
       119
       +
                 "blobs",

     

       120
       120
       +
                 "time"

     

       121
       121
       +
               ],

     

       122
       122
       +
               "type" => "object"

     

       123
       123
       +
             },

     

       124
       124
       +
             "identity" => %{

     

       125
       125
       +
               "description" =>

     

       126
       126
       +
                 "Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.",

     

       127
       127
       +
               "properties" => %{

     

       128
       128
       +
                 "did" => %{"format" => "did", "type" => "string"},

     

       129
       129
       +
                 "handle" => %{

     

       130
       130
       +
                   "description" =>

     

       131
       131
       +
                     "The current handle for the account, or 'handle.invalid' if validation fails. This field is optional, might have been validated or passed-through from an upstream source. Semantics and behaviors for PDS vs Relay may evolve in the future; see atproto specs for more details.",

     

       132
       132
       +
                   "format" => "handle",

     

       133
       133
       +
                   "type" => "string"

     

       134
       134
       +
                 },

     

       135
       135
       +
                 "seq" => %{"type" => "integer"},

     

       136
       136
       +
                 "time" => %{"format" => "datetime", "type" => "string"}

     

       137
       137
       +
               },

     

       138
       138
       +
               "required" => ["seq", "did", "time"],

     

       139
       139
       +
               "type" => "object"

     

       140
       140
       +
             },

     

       141
       141
       +
             "info" => %{

     

       142
       142
       +
               "properties" => %{

     

       143
       143
       +
                 "message" => %{"type" => "string"},

     

       144
       144
       +
                 "name" => %{"knownValues" => ["OutdatedCursor"], "type" => "string"}

     

       145
       145
       +
               },

     

       146
       146
       +
               "required" => ["name"],

     

       147
       147
       +
               "type" => "object"

     

       148
       148
       +
             },

     

       149
       149
       +
             "main" => %{

     

       150
       150
       +
               "description" =>

     

       151
       151
       +
                 "Repository event stream, aka Firehose endpoint. Outputs repo commits with diff data, and identity update events, for all repositories on the current server. See the atproto specifications for details around stream sequencing, repo versioning, CAR diff format, and more. Public and does not require auth; implemented by PDS and Relay.",

     

       152
       152
       +
               "errors" => [

     

       153
       153
       +
                 %{"name" => "FutureCursor"},

     

       154
       154
       +
                 %{

     

       155
       155
       +
                   "description" =>

     

       156
       156
       +
                     "If the consumer of the stream can not keep up with events, and a backlog gets too large, the server will drop the connection.",

     

       157
       157
       +
                   "name" => "ConsumerTooSlow"

     

       158
       158
       +
                 }

     

       159
       159
       +
               ],

     

       160
       160
       +
               "message" => %{

     

       161
       161
       +
                 "schema" => %{

     

       162
       162
       +
                   "refs" => ["#commit", "#sync", "#identity", "#account", "#info"],

     

       163
       163
       +
                   "type" => "union"

     

       164
       164
       +
                 }

     

       165
       165
       +
               },

     

       166
       166
       +
               "parameters" => %{

     

       167
       167
       +
                 "properties" => %{

     

       168
       168
       +
                   "cursor" => %{

     

       169
       169
       +
                     "description" => "The last known event seq number to backfill from.",

     

       170
       170
       +
                     "type" => "integer"

     

       171
       171
       +
                   }

     

       172
       172
       +
                 },

     

       173
       173
       +
                 "type" => "params"

     

       174
       174
       +
               },

     

       175
       175
       +
               "type" => "subscription"

     

       176
       176
       +
             },

     

       177
       177
       +
             "repoOp" => %{

     

       178
       178
       +
               "description" => "A repo operation, ie a mutation of a single record.",

     

       179
       179
       +
               "nullable" => ["cid"],

     

       180
       180
       +
               "properties" => %{

     

       181
       181
       +
                 "action" => %{

     

       182
       182
       +
                   "knownValues" => ["create", "update", "delete"],

     

       183
       183
       +
                   "type" => "string"

     

       184
       184
       +
                 },

     

       185
       185
       +
                 "cid" => %{

     

       186
       186
       +
                   "description" => "For creates and updates, the new record CID. For deletions, null.",

     

       187
       187
       +
                   "type" => "cid-link"

     

       188
       188
       +
                 },

     

       189
       189
       +
                 "path" => %{"type" => "string"},

     

       190
       190
       +
                 "prev" => %{

     

       191
       191
       +
                   "description" =>

     

       192
       192
       +
                     "For updates and deletes, the previous record CID (required for inductive firehose). For creations, field should not be defined.",

     

       193
       193
       +
                   "type" => "cid-link"

     

       194
       194
       +
                 }

     

       195
       195
       +
               },

     

       196
       196
       +
               "required" => ["action", "path", "cid"],

     

       197
       197
       +
               "type" => "object"

     

       198
       198
       +
             },

     

       199
       199
       +
             "sync" => %{

     

       200
       200
       +
               "description" =>

     

       201
       201
       +
                 "Updates the repo to a new state, without necessarily including that state on the firehose. Used to recover from broken commit streams, data loss incidents, or in situations where upstream host does not know recent state of the repository.",

     

       202
       202
       +
               "properties" => %{

     

       203
       203
       +
                 "blocks" => %{

     

       204
       204
       +
                   "description" =>

     

       205
       205
       +
                     "CAR file containing the commit, as a block. The CAR header must include the commit block CID as the first 'root'.",

     

       206
       206
       +
                   "maxLength" => 10000,

     

       207
       207
       +
                   "type" => "bytes"

     

       208
       208
       +
                 },

     

       209
       209
       +
                 "did" => %{

     

       210
       210
       +
                   "description" =>

     

       211
       211
       +
                     "The account this repo event corresponds to. Must match that in the commit object.",

     

       212
       212
       +
                   "format" => "did",

     

       213
       213
       +
                   "type" => "string"

     

       214
       214
       +
                 },

     

       215
       215
       +
                 "rev" => %{

     

       216
       216
       +
                   "description" =>

     

       217
       217
       +
                     "The rev of the commit. This value must match that in the commit object.",

     

       218
       218
       +
                   "type" => "string"

     

       219
       219
       +
                 },

     

       220
       220
       +
                 "seq" => %{

     

       221
       221
       +
                   "description" => "The stream sequence number of this message.",

     

       222
       222
       +
                   "type" => "integer"

     

       223
       223
       +
                 },

     

       224
       224
       +
                 "time" => %{

     

       225
       225
       +
                   "description" => "Timestamp of when this message was originally broadcast.",

     

       226
       226
       +
                   "format" => "datetime",

     

       227
       227
       +
                   "type" => "string"

     

       228
       228
       +
                 }

     

       229
       229
       +
               },

     

       230
       230
       +
               "required" => ["seq", "did", "blocks", "rev", "time"],

     

       231
       231
       +
               "type" => "object"

     

       232
       232
       +
             }

     

       233
       233
       +
           },

     

       234
       234
       +
           "id" => "com.atproto.sync.subscribeRepos",

     

       235
       235
       +
           "lexicon" => 1

     

       236
       236
       +
         })

     

       237
       237
       +
       end

-158

lib/aturi.ex

···

       1
       1
       -
       defmodule Atex.AtURI do

     

       2
       2
       -
         @moduledoc """

     

       3
       3
       -
         Struct and helper functions for manipulating `at://` URIs, which identify

     

       4
       4
       -
         specific records within the AT Protocol. For more information on the URI

     

       5
       5
       -
         scheme, refer to the ATProto spec: https://atproto.com/specs/at-uri-scheme.

     

       6
       6
       -
       

     

       7
       7
       -
         This module only supports the restricted URI syntax used for the Lexicon

     

       8
       8
       -
         `at-uri` type, with no support for query strings or fragments. If/when the

     

       9
       9
       -
         full syntax gets widespread use, this module will expand to accomodate them.

     

       10
       10
       -
       

     

       11
       11
       -
         Both URIs using DIDs and handles ("example.com") are supported.

     

       12
       12
       -
         """

     

       13
       13
       -
       

     

       14
       14
       -
         use TypedStruct

     

       15
       15
       -
       

     

       16
       16
       -
         @did ~S"did:(?:plc|web):[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]"

     

       17
       17
       -
         @handle ~S"(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?"

     

       18
       18
       -
         @nsid ~S"[a-zA-Z](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?:\.[a-zA-Z](?:[a-zA-Z0-9]{0,62})?)"

     

       19
       19
       -
       

     

       20
       20
       -
         @authority "(?<authority>(?:#{@did})|(?:#{@handle}))"

     

       21
       21
       -
         @collection "(?<collection>#{@nsid})"

     

       22
       22
       -
         @rkey "(?<rkey>[a-zA-Z0-9.-_:~]{1,512})"

     

       23
       23
       -
       

     

       24
       24
       -
         @re ~r"^at://#{@authority}(?:/#{@collection}(?:/#{@rkey})?)?$"

     

       25
       25
       -
       

     

       26
       26
       -
         typedstruct do

     

       27
       27
       -
           field :authority, String.t(), enforce: true

     

       28
       28
       -
           field :collection, String.t() | nil

     

       29
       29
       -
           field :rkey, String.t() | nil

     

       30
       30
       -
         end

     

       31
       31
       -
       

     

       32
       32
       -
         @doc """

     

       33
       33
       -
         Create a new AtURI struct from a string by matching it against the regex.

     

       34
       34
       -
       

     

       35
       35
       -
         Returns `{:ok, aturi}` if a valid `at://` URI is given, otherwise it will return `:error`.

     

       36
       36
       -
       

     

       37
       37
       -
         ## Examples

     

       38
       38
       -
       

     

       39
       39
       -
             iex> Atex.AtURI.new("at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26")

     

       40
       40
       -
             {:ok, %Atex.AtURI{

     

       41
       41
       -
               rkey: "3jwdwj2ctlk26",

     

       42
       42
       -
               collection: "app.bsky.feed.post",

     

       43
       43
       -
               authority: "did:plc:44ybard66vv44zksje25o7dz"

     

       44
       44
       -
             }}

     

       45
       45
       -
       

     

       46
       46
       -
             iex> Atex.AtURI.new("at:invalid/malformed")

     

       47
       47
       -
             :error

     

       48
       48
       -
       

     

       49
       49
       -
         Partial URIs pointing to a collection without a record key, or even just a given authority, are also supported:

     

       50
       50
       -
       

     

       51
       51
       -
             iex> Atex.AtURI.new("at://ovyerus.com/sh.comet.v0.feed.track")

     

       52
       52
       -
             {:ok, %Atex.AtURI{

     

       53
       53
       -
               rkey: nil,

     

       54
       54
       -
               collection: "sh.comet.v0.feed.track",

     

       55
       55
       -
               authority: "ovyerus.com"

     

       56
       56
       -
             }}

     

       57
       57
       -
       

     

       58
       58
       -
             iex> Atex.AtURI.new("at://did:web:comet.sh")

     

       59
       59
       -
             {:ok, %Atex.AtURI{

     

       60
       60
       -
               rkey: nil,

     

       61
       61
       -
               collection: nil,

     

       62
       62
       -
               authority: "did:web:comet.sh"

     

       63
       63
       -
             }}

     

       64
       64
       -
         """

     

       65
       65
       -
         @spec new(String.t()) :: {:ok, t()} | :error

     

       66
       66
       -
         def new(string) when is_binary(string) do

     

       67
       67
       -
           # TODO: test different ways to get a good error from regex on which part failed match?

     

       68
       68
       -
           case Regex.named_captures(@re, string) do

     

       69
       69
       -
             %{} = captures -> {:ok, from_named_captures(captures)}

     

       70
       70
       -
             nil -> :error

     

       71
       71
       -
           end

     

       72
       72
       -
         end

     

       73
       73
       -
       

     

       74
       74
       -
         @doc """

     

       75
       75
       -
         The same as `new/1` but raises an `ArgumentError` if an invalid string is given.

     

       76
       76
       -
       

     

       77
       77
       -
         ## Examples

     

       78
       78
       -
       

     

       79
       79
       -
             iex> Atex.AtURI.new!("at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26")

     

       80
       80
       -
             %Atex.AtURI{

     

       81
       81
       -
               rkey: "3jwdwj2ctlk26",

     

       82
       82
       -
               collection: "app.bsky.feed.post",

     

       83
       83
       -
               authority: "did:plc:44ybard66vv44zksje25o7dz"

     

       84
       84
       -
             }

     

       85
       85
       -
       

     

       86
       86
       -
             iex> Atex.AtURI.new!("at:invalid/malformed")

     

       87
       87
       -
             ** (ArgumentError) Malformed at:// URI

     

       88
       88
       -
         """

     

       89
       89
       -
         @spec new!(String.t()) :: t()

     

       90
       90
       -
         def new!(string) when is_binary(string) do

     

       91
       91
       -
           case new(string) do

     

       92
       92
       -
             {:ok, uri} -> uri

     

       93
       93
       -
             :error -> raise ArgumentError, message: "Malformed at:// URI"

     

       94
       94
       -
           end

     

       95
       95
       -
         end

     

       96
       96
       -
       

     

       97
       97
       -
         @doc """

     

       98
       98
       -
         Check if a string is a valid `at://` URI.

     

       99
       99
       -
       

     

       100
       100
       -
         ## Examples

     

       101
       101
       -
       

     

       102
       102
       -
             iex> Atex.AtURI.match?("at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26")

     

       103
       103
       -
             true

     

       104
       104
       -
       

     

       105
       105
       -
             iex> Atex.AtURI.match?("at://did:web:comet.sh")

     

       106
       106
       -
             true

     

       107
       107
       -
       

     

       108
       108
       -
             iex> Atex.AtURI.match?("at://ovyerus.com/sh.comet.v0.feed.track")

     

       109
       109
       -
             true

     

       110
       110
       -
       

     

       111
       111
       -
             iex> Atex.AtURI.match?("gobbledy gook")

     

       112
       112
       -
             false

     

       113
       113
       -
         """

     

       114
       114
       -
         @spec match?(String.t()) :: boolean()

     

       115
       115
       -
         def match?(string), do: Regex.match?(@re, string)

     

       116
       116
       -
       

     

       117
       117
       -
         @doc """

     

       118
       118
       -
         Format an `Atex.AtURI` to the canonical string representation.

     

       119
       119
       -
       

     

       120
       120
       -
         Also available via the `String.Chars` protocol.

     

       121
       121
       -
       

     

       122
       122
       -
         ## Examples

     

       123
       123
       -
       

     

       124
       124
       -
             iex> aturi = %Atex.AtURI{

     

       125
       125
       -
             ...>   rkey: "3jwdwj2ctlk26",

     

       126
       126
       -
             ...>   collection: "app.bsky.feed.post",

     

       127
       127
       -
             ...>   authority: "did:plc:44ybard66vv44zksje25o7dz"

     

       128
       128
       -
             ...> }

     

       129
       129
       -
             iex> Atex.AtURI.to_string(aturi)

     

       130
       130
       -
             "at://did:plc:44ybard66vv44zksje25o7dz/app.bsky.feed.post/3jwdwj2ctlk26"

     

       131
       131
       -
       

     

       132
       132
       -
             iex> aturi = %Atex.AtURI{authority: "did:web:comet.sh"}

     

       133
       133
       -
             iex> to_string(aturi)

     

       134
       134
       -
             "at://did:web:comet.sh"

     

       135
       135
       -
         """

     

       136
       136
       -
         @spec to_string(t()) :: String.t()

     

       137
       137
       -
         def to_string(%__MODULE__{} = uri) do

     

       138
       138
       -
           "at://#{uri.authority}/#{uri.collection}/#{uri.rkey}"

     

       139
       139
       -
           |> String.trim_trailing("/")

     

       140
       140
       -
         end

     

       141
       141
       -
       

     

       142
       142
       -
         defp from_named_captures(%{"authority" => authority, "collection" => "", "rkey" => ""}),

     

       143
       143
       -
           do: %__MODULE__{authority: authority}

     

       144
       144
       -
       

     

       145
       145
       -
         defp from_named_captures(%{"authority" => authority, "collection" => collection, "rkey" => ""}),

     

       146
       146
       -
           do: %__MODULE__{authority: authority, collection: collection}

     

       147
       147
       -
       

     

       148
       148
       -
         defp from_named_captures(%{

     

       149
       149
       -
                "authority" => authority,

     

       150
       150
       -
                "collection" => collection,

     

       151
       151
       -
                "rkey" => rkey

     

       152
       152
       -
              }),

     

       153
       153
       -
              do: %__MODULE__{authority: authority, collection: collection, rkey: rkey}

     

       154
       154
       -
       end

     

       155
       155
       -
       

     

       156
       156
       -
       defimpl String.Chars, for: Atex.AtURI do

     

       157
       157
       -
         def to_string(%Atex.AtURI{} = uri), do: Atex.AtURI.to_string(uri)

     

       158
       158
       -
       end

+94

lib/mix/tasks/atex.lexicons.ex

···

       1
       1
       +
       defmodule Mix.Tasks.Atex.Lexicons do

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         Generate Elixir modules from AT Protocol lexicons, which can then be used to

     

       4
       4
       +
         validate data at runtime.

     

       5
       5
       +
       

     

       6
       6
       +
         AT Protocol lexicons are JSON files that define parts of the AT Protocol data

     

       7
       7
       +
         model. This task processes these lexicon files and generates corresponding

     

       8
       8
       +
         Elixir modules.

     

       9
       9
       +
       

     

       10
       10
       +
         ## Usage

     

       11
       11
       +
       

     

       12
       12
       +
             mix atex.lexicons [OPTIONS] [PATHS]

     

       13
       13
       +
       

     

       14
       14
       +
         ## Arguments

     

       15
       15
       +
       

     

       16
       16
       +
         - `PATHS` - List of lexicon files to process. Also supports standard glob

     

       17
       17
       +
           syntax for reading many lexicons at once.

     

       18
       18
       +
       

     

       19
       19
       +
         ## Options

     

       20
       20
       +
       

     

       21
       21
       +
         - `-o`/`--output` - Output directory for generated modules (default:

     

       22
       22
       +
         `lib/atproto`)

     

       23
       23
       +
       

     

       24
       24
       +
         ## Examples

     

       25
       25
       +
       

     

       26
       26
       +
         Process all JSON files in the lexicons directory:

     

       27
       27
       +
       

     

       28
       28
       +
             mix atex.lexicons lexicons/**/*.json

     

       29
       29
       +
       

     

       30
       30
       +
         Process specific lexicon files:

     

       31
       31
       +
       

     

       32
       32
       +
             mix atex.lexicons lexicons/com/atproto/repo/*.json lexicons/app/bsky/actor/profile.json

     

       33
       33
       +
       

     

       34
       34
       +
         Generate modules to a custom output directory:

     

       35
       35
       +
       

     

       36
       36
       +
             mix atex.lexicons lexicons/**/*.json --output lib/my_atproto

     

       37
       37
       +
         """

     

       38
       38
       +
         @shortdoc "Generate Elixir modules from AT Protocol lexicons."

     

       39
       39
       +
       

     

       40
       40
       +
         use Mix.Task

     

       41
       41
       +
         require EEx

     

       42
       42
       +
       

     

       43
       43
       +
         @switches [output: :string]

     

       44
       44
       +
         @aliases [o: :output]

     

       45
       45
       +
         @template_path Path.expand("../../../priv/templates/lexicon.eex", __DIR__)

     

       46
       46
       +
       

     

       47
       47
       +
         @impl true

     

       48
       48
       +
         def run(args) do

     

       49
       49
       +
           {options, globs} = OptionParser.parse!(args, switches: @switches, aliases: @aliases)

     

       50
       50
       +
       

     

       51
       51
       +
           output = Keyword.get(options, :output, "lib/atproto")

     

       52
       52
       +
           paths = Enum.flat_map(globs, &Path.wildcard/1)

     

       53
       53
       +
       

     

       54
       54
       +
           if length(paths) == 0 do

     

       55
       55
       +
             Mix.shell().error("No valid search paths have been provided, aborting.")

     

       56
       56
       +
           else

     

       57
       57
       +
             Mix.shell().info("Generating modules for lexicons into #{output}")

     

       58
       58
       +
       

     

       59
       59
       +
             Enum.each(paths, fn path ->

     

       60
       60
       +
               Mix.shell().info("- #{path}")

     

       61
       61
       +
               generate(path, output)

     

       62
       62
       +
             end)

     

       63
       63
       +
           end

     

       64
       64
       +
         end

     

       65
       65
       +
       

     

       66
       66
       +
         # TODO: validate schema?

     

       67
       67
       +
         defp generate(input, output) do

     

       68
       68
       +
           lexicon =

     

       69
       69
       +
             input

     

       70
       70
       +
             |> File.read!()

     

       71
       71
       +
             |> JSON.decode!()

     

       72
       72
       +
       

     

       73
       73
       +
           if not is_binary(lexicon["id"]) do

     

       74
       74
       +
             raise ArgumentError, message: "Malformed lexicon: does not have an `id` field."

     

       75
       75
       +
           end

     

       76
       76
       +
       

     

       77
       77
       +
           code = lexicon |> template() |> Code.format_string!() |> Enum.join("")

     

       78
       78
       +
       

     

       79
       79
       +
           file_path =

     

       80
       80
       +
             lexicon["id"]

     

       81
       81
       +
             |> String.split(".")

     

       82
       82
       +
             |> Enum.join("/")

     

       83
       83
       +
             |> then(&(&1 <> ".ex"))

     

       84
       84
       +
             |> then(&Path.join(output, &1))

     

       85
       85
       +
       

     

       86
       86
       +
           file_path

     

       87
       87
       +
           |> Path.dirname()

     

       88
       88
       +
           |> File.mkdir_p!()

     

       89
       89
       +
       

     

       90
       90
       +
           File.write!(file_path, code)

     

       91
       91
       +
         end

     

       92
       92
       +
       

     

       93
       93
       +
         EEx.function_from_file(:defp, :template, @template_path, [:lexicon])

     

       94
       94
       +
       end

+51 -4

mix.exs

···

       1
       1
        
       defmodule Atex.MixProject do

     

       2
       2
        
         use Mix.Project

     

       3
       3
        
       

     

       4
       4
       +
         @version "0.6.0"

     

       5
       5
       +
         @github "https://github.com/cometsh/atex"

     

       6
       6
       +
         @tangled "https://tangled.sh/@comet.sh/atex"

     

       7
       7
       +
       

     

       4
       8
        
         def project do

     

       5
       9
        
           [

     

       6
       10
        
             app: :atex,

     

       7
       7
       -
             version: "0.1.0",

     

       11
       11
       +
             version: @version,

     

       8
       12
        
             elixir: "~> 1.18",

     

       9
       13
        
             start_permanent: Mix.env() == :prod,

     

       10
       10
       -
             deps: deps()

     

       14
       14
       +
             deps: deps(),

     

       15
       15
       +
             name: "atex",

     

       16
       16
       +
             description: "A set of utilities for working with the AT Protocol in Elixir.",

     

       17
       17
       +
             package: package(),

     

       18
       18
       +
             docs: docs()

     

       11
       19
        
           ]

     

       12
       20
        
         end

     

       13
       21
        
       

     

       14
       22
        
         def application do

     

       15
       23
        
           [

     

       16
       16
       -
             extra_applications: [:logger]

     

       24
       24
       +
             extra_applications: [:logger],

     

       25
       25
       +
             mod: {Atex.Application, []}

     

       17
       26
        
           ]

     

       18
       27
        
         end

     

       19
       28
        
       

     

       20
       29
        
         defp deps do

     

       21
       30
        
           [

     

       31
       31
       +
             {:peri, "~> 0.6"},

     

       32
       32
       +
             {:multiformats_ex, "~> 0.2"},

     

       33
       33
       +
             {:recase, "~> 0.5"},

     

       34
       34
       +
             {:req, "~> 0.5"},

     

       22
       35
        
             {:typedstruct, "~> 0.5"},

     

       23
       23
       -
             {:ex_doc, "~> 0.34", only: :dev, runtime: false, warn_if_outdated: true}

     

       36
       36
       +
             {:ex_cldr, "~> 2.42"},

     

       37
       37
       +
             {:credo, "~> 1.7", only: [:dev, :test], runtime: false},

     

       38
       38
       +
             {:ex_doc, "~> 0.34", only: :dev, runtime: false, warn_if_outdated: true},

     

       39
       39
       +
             {:plug, "~> 1.18"},

     

       40
       40
       +
             {:jason, "~> 1.4"},

     

       41
       41
       +
             {:jose, "~> 1.11"},

     

       42
       42
       +
             {:bandit, "~> 1.0", only: [:dev, :test]}

     

       43
       43
       +
           ]

     

       44
       44
       +
         end

     

       45
       45
       +
       

     

       46
       46
       +
         defp package do

     

       47
       47
       +
           [

     

       48
       48
       +
             licenses: ["MIT"],

     

       49
       49
       +
             links: %{"GitHub" => @github, "Tangled" => @tangled}

     

       50
       50
       +
           ]

     

       51
       51
       +
         end

     

       52
       52
       +
       

     

       53
       53
       +
         defp docs do

     

       54
       54
       +
           [

     

       55
       55
       +
             extras: [

     

       56
       56
       +
               LICENSE: [title: "License"],

     

       57
       57
       +
               "README.md": [title: "Overview"],

     

       58
       58
       +
               "CHANGELOG.md": [title: "Changelog"]

     

       59
       59
       +
             ],

     

       60
       60
       +
             main: "readme",

     

       61
       61
       +
             source_url: @github,

     

       62
       62
       +
             source_ref: "v#{@version}",

     

       63
       63
       +
             formatters: ["html"],

     

       64
       64
       +
             groups_for_modules: [

     

       65
       65
       +
               "Data types": [Atex.AtURI, Atex.DID, Atex.Handle, Atex.NSID, Atex.TID],

     

       66
       66
       +
               XRPC: ~r/^Atex\.XRPC/,

     

       67
       67
       +
               OAuth: [Atex.Config.OAuth, Atex.OAuth, Atex.OAuth.Plug],

     

       68
       68
       +
               Lexicons: ~r/^Atex\.Lexicon/,

     

       69
       69
       +
               Identity: ~r/^Atex\.IdentityResolver/

     

       70
       70
       +
             ]

     

       24
       71
        
           ]

     

       25
       72
        
         end

     

       26
       73
        
       end

+27 -2

mix.lock

···

       1
       1
        
       %{

     

       2
       2
       +
         "bandit": {:hex, :bandit, "1.8.0", "c2e93d7e3c5c794272fa4623124f827c6f24b643acc822be64c826f9447d92fb", [:mix], [{:hpax, "~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.0", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "8458ff4eed20ff2a2ea69d4854883a077c33ea42b51f6811b044ceee0fa15422"},

     

       3
       3
       +
         "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},

     

       4
       4
       +
         "cldr_utils": {:hex, :cldr_utils, "2.28.3", "d0ac5ed25913349dfaca8b7fe14722d588d8ccfa3e335b0510c7cc3f3c54d4e6", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.5", [hex: :certifi, repo: "hexpm", optional: true]}, {:decimal, "~> 1.9 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm", "40083cd9a5d187f12d675cfeeb39285f0d43e7b7f2143765161b72205d57ffb5"},

     

       5
       5
       +
         "credo": {:hex, :credo, "1.7.12", "9e3c20463de4b5f3f23721527fcaf16722ec815e70ff6c60b86412c695d426c1", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "8493d45c656c5427d9c729235b99d498bd133421f3e0a683e5c1b561471291e5"},

     

       6
       6
       +
         "decimal": {:hex, :decimal, "2.3.0", "3ad6255aa77b4a3c4f818171b12d237500e63525c2fd056699967a3e7ea20f62", [:mix], [], "hexpm", "a4d66355cb29cb47c3cf30e71329e58361cfcb37c34235ef3bf1d7bf3773aeac"},

     

       2
       7
        
         "earmark_parser": {:hex, :earmark_parser, "1.4.44", "f20830dd6b5c77afe2b063777ddbbff09f9759396500cdbe7523efd58d7a339c", [:mix], [], "hexpm", "4778ac752b4701a5599215f7030989c989ffdc4f6df457c5f36938cc2d2a2750"},

     

       3
       3
       -
         "ex_doc": {:hex, :ex_doc, "0.38.2", "504d25eef296b4dec3b8e33e810bc8b5344d565998cd83914ffe1b8503737c02", [:mix], [{:earmark_parser, "~> 1.4.44", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "732f2d972e42c116a70802f9898c51b54916e542cc50968ac6980512ec90f42b"},

     

       8
       8
       +
         "ex_cldr": {:hex, :ex_cldr, "2.43.0", "8700031e30a03501cf65f7ba7c8287bb67339d03559f3108f3c54fe86d926b19", [:mix], [{:cldr_utils, "~> 2.28", [hex: :cldr_utils, repo: "hexpm", optional: false]}, {:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:gettext, "~> 0.19", [hex: :gettext, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: true]}], "hexpm", "1524eb01275b89473ee5f53fcc6169bae16e4a5267ef109229f37694799e0b20"},

     

       9
       9
       +
         "ex_doc": {:hex, :ex_doc, "0.38.3", "ddafe36b8e9fe101c093620879f6604f6254861a95133022101c08e75e6c759a", [:mix], [{:earmark_parser, "~> 1.4.44", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "ecaa785456a67f63b4e7d7f200e8832fa108279e7eb73fd9928e7e66215a01f9"},

     

       10
       10
       +
         "file_system": {:hex, :file_system, "1.1.0", "08d232062284546c6c34426997dd7ef6ec9f8bbd090eb91780283c9016840e8f", [:mix], [], "hexpm", "bfcf81244f416871f2a2e15c1b515287faa5db9c6bcf290222206d120b3d43f6"},

     

       11
       11
       +
         "finch": {:hex, :finch, "0.20.0", "5330aefb6b010f424dcbbc4615d914e9e3deae40095e73ab0c1bb0968933cadf", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.6.2 or ~> 1.7", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "2658131a74d051aabfcba936093c903b8e89da9a1b63e430bee62045fa9b2ee2"},

     

       12
       12
       +
         "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"},

     

       13
       13
       +
         "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"},

     

       14
       14
       +
         "jose": {:hex, :jose, "1.11.10", "a903f5227417bd2a08c8a00a0cbcc458118be84480955e8d251297a425723f83", [:mix, :rebar3], [], "hexpm", "0d6cd36ff8ba174db29148fc112b5842186b68a90ce9fc2b3ec3afe76593e614"},

     

       4
       15
        
         "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},

     

       5
       16
        
         "makeup_elixir": {:hex, :makeup_elixir, "1.0.1", "e928a4f984e795e41e3abd27bfc09f51db16ab8ba1aebdba2b3a575437efafc2", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "7284900d412a3e5cfd97fdaed4f5ed389b8f2b4cb49efc0eb3bd10e2febf9507"},

     

       6
       17
        
         "makeup_erlang": {:hex, :makeup_erlang, "1.0.2", "03e1804074b3aa64d5fad7aa64601ed0fb395337b982d9bcf04029d68d51b6a7", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "af33ff7ef368d5893e4a267933e7744e46ce3cf1f61e2dccf53a111ed3aa3727"},

     

       18
       18
       +
         "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"},

     

       19
       19
       +
         "mint": {:hex, :mint, "1.7.1", "113fdb2b2f3b59e47c7955971854641c61f378549d73e829e1768de90fc1abf1", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "fceba0a4d0f24301ddee3024ae116df1c3f4bb7a563a731f45fdfeb9d39a231b"},

     

       20
       20
       +
         "multiformats_ex": {:hex, :multiformats_ex, "0.2.0", "5b0a3faa1a770dc671aa8a89b6323cc20b0ecf67dc93dcd21312151fbea6b4ee", [:mix], [{:varint, "~> 1.4", [hex: :varint, repo: "hexpm", optional: false]}], "hexpm", "aa406d9addb06dc197e0e92212992486af6599158d357680f29f2d11e08d0423"},

     

       21
       21
       +
         "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"},

     

       7
       22
        
         "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},

     

       8
       8
       -
         "typedstruct": {:hex, :typedstruct, "0.5.3", "d68ae424251a41b81a8d0c485328ab48edbd3858f3565bbdac21b43c056fc9b4", [:make, :mix], [], "hexpm", "b53b8186701417c0b2782bf02a2db5524f879b8488f91d1d83b97d84c2943432"},

     

       23
       23
       +
         "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"},

     

       24
       24
       +
         "peri": {:hex, :peri, "0.6.1", "6a90ca728a27aef8fef37ce307444255d20364b0c8f8d39e52499d8d825cb514", [:mix], [{:ecto, "~> 3.12", [hex: :ecto, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:stream_data, "~> 1.1", [hex: :stream_data, repo: "hexpm", optional: true]}], "hexpm", "e20ffc659967baf9c4f28799fe7302b656d6662a8b3db7646fdafd017e192743"},

     

       25
       25
       +
         "plug": {:hex, :plug, "1.18.1", "5067f26f7745b7e31bc3368bc1a2b818b9779faa959b49c934c17730efc911cf", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "57a57db70df2b422b564437d2d33cf8d33cd16339c1edb190cd11b1a3a546cc2"},

     

       26
       26
       +
         "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"},

     

       27
       27
       +
         "recase": {:hex, :recase, "0.9.0", "437982693fdfbec125f11c8868eb3b4d32e9aa6995d3a68ac8686f3e2bf5d8d1", [:mix], [], "hexpm", "efa7549ebd128988d1723037a6f6a61948055aec107db6288f1c52830cb6501c"},

     

       28
       28
       +
         "req": {:hex, :req, "0.5.15", "662020efb6ea60b9f0e0fac9be88cd7558b53fe51155a2d9899de594f9906ba9", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "a6513a35fad65467893ced9785457e91693352c70b58bbc045b47e5eb2ef0c53"},

     

       29
       29
       +
         "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"},

     

       30
       30
       +
         "thousand_island": {:hex, :thousand_island, "1.4.1", "8df065e627407e281f7935da5ad0f3842d10eb721afa92e760b720d71e2e37aa", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "204a8640e5d2818589b87286ae66160978628d7edf6095181cbe0440765fb6c1"},

     

       31
       31
       +
         "typedstruct": {:hex, :typedstruct, "0.5.4", "d1d33d58460a74f413e9c26d55e66fd633abd8ac0fb12639add9a11a60a0462a", [:make, :mix], [], "hexpm", "ffaef36d5dbaebdbf4ed07f7fb2ebd1037b2c1f757db6fb8e7bcbbfabbe608d8"},

     

       32
       32
       +
         "varint": {:hex, :varint, "1.5.1", "17160c70d0428c3f8a7585e182468cac10bbf165c2360cf2328aaa39d3fb1795", [:mix], [], "hexpm", "24f3deb61e91cb988056de79d06f01161dd01be5e0acae61d8d936a552f1be73"},

     

       33
       33
       +
         "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},

     

       9
       34
        
       }

priv/templates/lexicon.eex

···

       1
       1
       +
       defmodule <%= Atex.NSID.to_atom(lexicon["id"], false) %> do

     

       2
       2
       +
         use Atex.Lexicon

     

       3
       3
       +
       

     

       4
       4
       +
         deflexicon(<%= inspect(lexicon, limit: :infinity, pretty: true, printable_limit: :infinity) %>)

     

       5
       5
       +
       end

test/tid_test.exs

···

       1
       1
       +
       defmodule TIDTest do

     

       2
       2
       +
         use ExUnit.Case, async: true

     

       3
       3
       +
         doctest Atex.TID

     

       4
       4
       +
       end

Compare changes