comparing a5d95b4d546f83e71ae0ca3aab858d23cd43ee3a and main on comet.sh/atex

+2 -2

.formatter.exs

···

       1
       1
        
       # Used by "mix format"

     

       2
       2
        
       [

     

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

     

       4
       4
       -
         import_deps: [:typedstruct, :peri],

     

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

     
···

       27
       12
        
       .vscode/

     

       28
       13
        
       .elixir_ls

     

       29
       14
        
       lexicons

     

       30
       30
       -
       lib/atproto
     

       15
       15
       +
       secrets

     

       16
       16
       +
       .DS_Store

     

       17
       17
       +
       CLAUDE.md

     

       18
       18
       +
       tmp

     

       19
       19
       +
       temp

+37 -1

CHANGELOG.md

···

       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
       +
       

     

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

     

       12
       46
        
       

     

       13
       47
        
       ### Added

     
···

       46
       80
        
       

     

       47
       81
        
       Initial release.

     

       48
       82
        
       

     

       49
       49
       -
       [unreleased]: https://github.com/cometsh/atex/compare/v0.4.0...HEAD

     

       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

     

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

     

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

     

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

+5 -3

README.md

···

       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
       -
       - [ ] Extended XRPC client with support for validated inputs/outputs

     

       15
       15
       -
       - [ ] Oauth stuff

     

       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

     

       16
       18
        
       

     

       17
       19
        
       ## Installation

     

       18
       20
        
       

     
···

       21
       23
        
       ```elixir

     

       22
       24
        
       def deps do

     

       23
       25
        
         [

     

       24
       24
       -
           {:atex, "~> 0.3"}

     

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

     

       25
       27
        
         ]

     

       26
       28
        
       end

     

       27
       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

+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

-38

lib/atex/http/adapter/req.ex

···

       1
       1
       -
       defmodule Atex.HTTP.Adapter.Req do

     

       2
       2
       -
         @moduledoc """

     

       3
       3
       -
         `Req` adapter for atex.

     

       4
       4
       -
         """

     

       5
       5
       -
       

     

       6
       6
       -
         @behaviour Atex.HTTP.Adapter

     

       7
       7
       -
       

     

       8
       8
       -
         @impl true

     

       9
       9
       -
         def get(url, opts) do

     

       10
       10
       -
           Req.get(url, opts) |> adapt()

     

       11
       11
       -
         end

     

       12
       12
       -
       

     

       13
       13
       -
         @impl true

     

       14
       14
       -
         def post(url, opts) do

     

       15
       15
       -
           Req.post(url, opts) |> adapt()

     

       16
       16
       -
         end

     

       17
       17
       -
       

     

       18
       18
       -
         @spec adapt({:ok, Req.Response.t()} | {:error, any()}) :: Atex.HTTP.Adapter.result()

     

       19
       19
       -
         defp adapt({:ok, %Req.Response{status: status} = res}) when status < 400 do

     

       20
       20
       -
           {:ok, to_response(res)}

     

       21
       21
       -
         end

     

       22
       22
       -
       

     

       23
       23
       -
         defp adapt({:ok, %Req.Response{} = res}) do

     

       24
       24
       -
           {:error, to_response(res)}

     

       25
       25
       -
         end

     

       26
       26
       -
       

     

       27
       27
       -
         defp adapt({:error, exception}) do

     

       28
       28
       -
           {:error, exception}

     

       29
       29
       -
         end

     

       30
       30
       -
       

     

       31
       31
       -
         defp to_response(%Req.Response{} = res) do

     

       32
       32
       -
           %Atex.HTTP.Response{

     

       33
       33
       -
             body: res.body,

     

       34
       34
       -
             status: res.status,

     

       35
       35
       -
             __raw__: res

     

       36
       36
       -
           }

     

       37
       37
       -
         end

     

       38
       38
       -
       end

-13

lib/atex/http/adapter.ex

···

       1
       1
       -
       defmodule Atex.HTTP.Adapter do

     

       2
       2
       -
         @moduledoc """

     

       3
       3
       -
         Behaviour for defining a HTTP client adapter to be used within atex.

     

       4
       4
       -
         """

     

       5
       5
       -
         alias Atex.HTTP.Response

     

       6
       6
       -
       

     

       7
       7
       -
         @type success() :: {:ok, Response.t()}

     

       8
       8
       -
         @type error() :: {:error, Response.t() | term()}

     

       9
       9
       -
         @type result() :: success() | error()

     

       10
       10
       -
       

     

       11
       11
       -
         @callback get(url :: String.t(), opts :: keyword()) :: result()

     

       12
       12
       -
         @callback post(url :: String.t(), opts :: keyword()) :: result()

     

       13
       13
       -
       end

-13

lib/atex/http/response.ex

···

       1
       1
       -
       defmodule Atex.HTTP.Response do

     

       2
       2
       -
         @moduledoc """

     

       3
       3
       -
         A generic response struct to be returned by an `Atex.HTTP.Adapter`.

     

       4
       4
       -
         """

     

       5
       5
       -
       

     

       6
       6
       -
         use TypedStruct

     

       7
       7
       -
       

     

       8
       8
       -
         typedstruct enforce: true do

     

       9
       9
       -
           field :status, integer()

     

       10
       10
       -
           field :body, any()

     

       11
       11
       -
           field :__raw__, any()

     

       12
       12
       -
         end

     

       13
       13
       -
       end

-6

lib/atex/http.ex

···

       1
       1
       -
       defmodule Atex.HTTP do

     

       2
       2
       -
         @adapter Application.compile_env(:atex, :adapter, Atex.HTTP.Adapter.Req)

     

       3
       3
       -
       

     

       4
       4
       -
         defdelegate get(url, opts), to: @adapter

     

       5
       5
       -
         defdelegate post(url, opts), to: @adapter

     

       6
       6
       -
       end

+2 -2

lib/atex/identity_resolver/did.ex

···

       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
       -
                  Atex.HTTP.get("https://plc.directory/#{did}", []),

     

       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

     
···

       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
       -
                  Atex.HTTP.get("https://#{domain}/.well-known/did.json", []),

     

       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

+13

lib/atex/identity_resolver/did_document.ex

···

       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
       +
       

     

       128
       141
        
         defp valid_pds_endpoint?(endpoint) do

     

       129
       142
        
           case URI.new(endpoint) do

     

       130
       143
        
             {:ok, uri} ->

+1 -1

lib/atex/identity_resolver/handle.ex

···

       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 Atex.HTTP.get("https://#{handle}/.well-known/atproto-did", []) 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

+2 -2

lib/atex/lexicon/validators/array.ex

···

       4
       4
        
         @option_keys [:min_length, :max_length]

     

       5
       5
        
       

     

       6
       6
        
         # Needs type input

     

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

     

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

     

       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

+13 -44

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 format() ::

     

       5
       5
       -
                 :at_identifier

     

       6
       6
       -
                 | :at_uri

     

       7
       7
       -
                 | :cid

     

       8
       8
       -
                 | :datetime

     

       9
       9
       -
                 | :did

     

       10
       10
       -
                 | :handle

     

       11
       11
       -
                 | :nsid

     

       12
       12
       -
                 | :tid

     

       13
       13
       -
                 | :record_key

     

       14
       14
       -
                 | :uri

     

       15
       15
       -
                 | :language

     

       16
       16
       -
       

     

       17
       4
        
         @type option() ::

     

       18
       18
       -
                 {:format, format()}

     

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

     

       19
       6
        
                 | {:min_length, non_neg_integer()}

     

       20
       7
        
                 | {:max_length, non_neg_integer()}

     

       21
       8
        
                 | {:min_graphemes, non_neg_integer()}

     
···

       31
       18
        
       

     

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

     

       33
       20
        
       

     

       34
       34
       -
         # TODO: probably should go into a different module, one with general lexicon -> validator gen conversions

     

       35
       35
       -
         @spec format_to_atom(String.t()) :: format()

     

       36
       36
       -
         def format_to_atom(format) do

     

       37
       37
       -
           case format do

     

       38
       38
       -
             "at-identifier" -> :at_identifier

     

       39
       39
       -
             "at-uri" -> :at_uri

     

       40
       40
       -
             "cid" -> :cid

     

       41
       41
       -
             "datetime" -> :datetime

     

       42
       42
       -
             "did" -> :did

     

       43
       43
       -
             "handle" -> :handle

     

       44
       44
       -
             "nsid" -> :nsid

     

       45
       45
       -
             "tid" -> :tid

     

       46
       46
       -
             "record-key" -> :record_key

     

       47
       47
       -
             "uri" -> :uri

     

       48
       48
       -
             "language" -> :language

     

       49
       49
       -
             _ -> raise "Unknown lexicon string format `#{format}`"

     

       50
       50
       -
           end

     

       51
       51
       -
         end

     

       52
       52
       -
       

     

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

     

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

     

       55
       23
        
           options

     
···

       74
       42
        
       

     

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

     

       76
       44
        
       

     

       77
       77
       -
         defp validate_option(value, {:format, :at_identifier}),

     

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

     

       78
       46
        
           do:

     

       79
       47
        
             Validators.boolean_validate(

     

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

     

       81
       49
        
               "should be a valid DID or handle"

     

       82
       50
        
             )

     

       83
       51
        
       

     

       84
       84
       -
         defp validate_option(value, {:format, :at_uri}),

     

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

     

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

     

       86
       54
        
       

     

       87
       87
       -
         defp validate_option(value, {:format, :cid}) do

     

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

     

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

     

       89
       57
        
           try do

     

       90
       58
        
             Multiformats.CID.decode(value)

     

       59
       59
       +
             :ok

     

       91
       60
        
           rescue

     

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

     

       93
       62
        
           end

     

       94
       63
        
         end

     

       95
       64
        
       

     

       96
       96
       -
         defp validate_option(value, {:format, :datetime}) do

     

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

     

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

     

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

     

       99
       68
        
           case NaiveDateTime.from_iso8601(value) do

     
···

       102
       71
        
           end

     

       103
       72
        
         end

     

       104
       73
        
       

     

       105
       105
       -
         defp validate_option(value, {:format, :did}),

     

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

     

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

     

       107
       76
        
       

     

       108
       108
       -
         defp validate_option(value, {:format, :handle}),

     

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

     

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

     

       110
       79
        
       

     

       111
       111
       -
         defp validate_option(value, {:format, :nsid}),

     

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

     

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

     

       113
       82
        
       

     

       114
       114
       -
         defp validate_option(value, {:format, :tid}),

     

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

     

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

     

       116
       85
        
       

     

       117
       117
       -
         defp validate_option(value, {:format, :record_key}),

     

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

     

       118
       87
        
           do:

     

       119
       88
        
             Validators.boolean_validate(

     

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

     

       121
       90
        
               "should be a valid record key"

     

       122
       91
        
             )

     

       123
       92
        
       

     

       124
       124
       -
         defp validate_option(value, {:format, :uri}) do

     

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

     

       125
       94
        
           case URI.new(value) do

     

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

     

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

     

       128
       97
        
           end

     

       129
       98
        
         end

     

       130
       99
        
       

     

       131
       131
       -
         defp validate_option(value, {:format, :language}) do

     

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

     

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

     

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

     

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

lib/atex/lexicon/validators.ex

···

       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
       +
       

     

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

     

       85
       90
        
                 Peri.validation_result()

     

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

+307 -59

lib/atex/lexicon.ex

···

       1
       1
        
       defmodule Atex.Lexicon do

     

       2
       2
       -
         @moduledoc """

     

       3
       3
       -
         Provide `deflexicon` macro for defining a module with types and schemas from an entire lexicon definition.

     

       4
       4
       -
       

     

       5
       5
       -
         Should it also define structs, with functions to convert from input case to snake case?

     

       6
       6
       -
         """

     

       7
       7
       -
       

     

       8
       2
        
         alias Atex.Lexicon.Validators

     

       9
       3
        
       

     

       10
       4
        
         defmacro __using__(_opts) do

     
···

       15
       9
        
           end

     

       16
       10
        
         end

     

       17
       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
       +
         """

     

       18
       79
        
         defmacro deflexicon(lexicon) do

     

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

     

       20
       81
        
           lexicon =

     
···

       27
       88
        
           defs =

     

       28
       89
        
             lexicon.defs

     

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

     

       30
       30
       -
             |> Enum.map(fn {schema_key, quoted_schema, quoted_type} ->

     

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

     

       31
       96
        
               identity_type =

     

       32
       32
       -
                 if schema_key === :main do

     

       97
       97
       +
                 if schema_key == :main do

     

       33
       98
        
                   quote do

     

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

     

       35
       100
        
                   end

     

       36
       101
        
                 end

     

       37
       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
       +
       

     

       38
       119
        
               quote do

     

       39
       39
       -
                 @type unquote(schema_key)() :: unquote(quoted_type)

     

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

     

       40
       121
        
                 unquote(identity_type)

     

       41
       122
        
       

     

       42
       42
       -
                 defschema unquote(schema_key), unquote(quoted_schema)

     

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

     

       124
       124
       +
       

     

       125
       125
       +
                 unquote(struct_def)

     

       43
       126
        
               end

     

       44
       127
        
             end)

     

       45
       128
        
       

     

       46
       129
        
           quote do

     

       47
       47
       -
             def id, do: unquote(Atex.NSID.to_atom(lexicon.id))

     

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

     

       48
       131
        
       

     

       49
       132
        
             unquote_splicing(defs)

     

       50
       133
        
           end

     

       51
       134
        
         end

     

       135
       135
       +
       

     

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

     

       52
       137
        
       

     

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

     

       54
       54
       -
                 list({key :: atom(), quoted_schema :: term(), quoted_type :: term()})

     

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

     

       55
       152
        
       

     

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

     

       57
       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
       +
       

     

       58
       164
        
           def_to_schema(nsid, def_name, record)

     

       59
       165
        
         end

     

       60
       166
        
       

     

       61
       61
       -
         # TODO: need to spit out an extra 'branded' type with `$type` field, for use in union refs.

     

       167
       167
       +
         # TODO: add struct to types

     

       62
       168
        
         defp def_to_schema(

     

       63
       169
        
                nsid,

     

       64
       170
        
                def_name,

     
···

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

     

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

     

       72
       178
        
       

     

       73
       73
       -
           properties

     

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

     

       75
       75
       -
             {quoted_schema, quoted_type} = field_to_schema(field, nsid)

     

       76
       76
       -
             is_nullable = key in nullable

     

       77
       77
       -
             is_required = key in required

     

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

     

       78
       194
        
       

     

       79
       79
       -
             quoted_schema =

     

       80
       80
       -
               quoted_schema

     

       81
       81
       -
               |> then(

     

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

     

       83
       83
       -
               )

     

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

     

       85
       85
       -
               |> then(&{key, &1})

     

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

     

       86
       196
        
       

     

       87
       87
       -
             key_type = if is_required, do: :required, else: :optional

     

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

     

       88
       207
        
       

     

       89
       89
       -
             quoted_type =

     

       90
       90
       -
               quoted_type

     

       91
       91
       -
               |> then(

     

       92
       92
       -
                 &if is_nullable do

     

       93
       93
       -
                   {:|, [], [&1, nil]}

     

       94
       94
       -
                 else

     

       95
       95
       -
                   &1

     

       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

     

       96
       246
        
                 end

     

       97
       97
       -
               )

     

       98
       98
       -
               |> then(&{{key_type, [], [key]}, &1})

     

       247
       247
       +
               end

     

       99
       248
        
       

     

       100
       100
       -
             {quoted_schema, quoted_type}

     

       101
       101
       -
           end)

     

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

     

       103
       103
       -
             {[quoted_schema | schemas], [quoted_type | types]}

     

       104
       104
       -
           end)

     

       105
       105
       -
           |> then(fn {quoted_schemas, quoted_types} ->

     

       106
       106
       -
             [{atomise(def_name), {:%{}, [], quoted_schemas}, {:%{}, [], quoted_types}}]

     

       107
       107
       -
           end)

     

       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}]

     

       108
       275
        
         end

     

       109
       276
        
       

     

       110
       277
        
         # TODO: validating errors?

     
···

       127
       294
        
               schema

     

       128
       295
        
             end

     

       129
       296
        
       

     

       130
       130
       -
           [params, output]

     

       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]

     

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

     

       132
       326
        
         end

     

       133
       327
        
       

     
···

       157
       351
        
               schema

     

       158
       352
        
             end

     

       159
       353
        
       

     

       160
       160
       -
           [params, output, input]

     

       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]

     

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

     

       162
       405
        
         end

     

       163
       406
        
       

     
···

       231
       474
        
               :minGraphemes

     

       232
       475
        
             ])

     

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

     

       234
       234
       -
             |> then(&{:custom, {Validators.String, :validate, [&1]}})

     

       477
       477
       +
             |> Validators.string()

     

       235
       478
        
             |> maybe_default(field)

     

       236
       479
        
           end

     

       237
       480
        
           |> then(

     
···

       262
       505
        
             field

     

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

     

       264
       507
        
             |> Keyword.new()

     

       265
       265
       -
             |> then(&{:custom, {Validators.Integer, [&1]}})

     

       508
       508
       +
             |> Validators.integer()

     

       266
       509
        
             |> maybe_default(field)

     

       267
       510
        
           end

     

       268
       511
        
           |> then(

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     
···

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

     

       342
       586
        
             |> Atex.NSID.to_atom_with_fragment()

     

       343
       587
        
       

     

       344
       344
       -
           {quote do

     

       345
       345
       -
              unquote(nsid).get_schema(unquote(fragment))

     

       346
       346
       -
            end,

     

       347
       347
       -
            quote do

     

       348
       348
       -
              unquote(nsid).unquote(fragment)()

     

       349
       349
       -
            end}

     

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

     

       350
       596
        
         end

     

       351
       597
        
       

     

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

     
···

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

     

       363
       609
        
                 |> Atex.NSID.to_atom_with_fragment()

     

       364
       610
        
       

     

       365
       365
       -
               {quote do

     

       366
       366
       -
                  unquote(nsid).get_schema(unquote(fragment))

     

       367
       367
       -
                end,

     

       368
       368
       -
                quote do

     

       369
       369
       -
                  unquote(nsid).unquote(fragment)()

     

       370
       370
       -
                end}

     

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

     

       371
       619
        
             end)

     

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

     

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

lib/atex/nsid.ex

···

       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

     

       48
       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

+18 -74

lib/atex/xrpc/client.ex

···

       1
       1
        
       defmodule Atex.XRPC.Client do

     

       2
       2
        
         @moduledoc """

     

       3
       3
       -
         Struct to store client information for ATProto XRPC.

     

       4
       4
       -
         """

     

       3
       3
       +
         Behaviour that defines the interface for XRPC clients.

     

       5
       4
        
       

     

       6
       6
       -
         alias Atex.{XRPC, HTTP}

     

       7
       7
       -
         use TypedStruct

     

       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.

     

       8
       7
        
       

     

       9
       9
       -
         typedstruct do

     

       10
       10
       -
           field :endpoint, String.t(), enforce: true

     

       11
       11
       -
           field :access_token, String.t() | nil

     

       12
       12
       -
           field :refresh_token, String.t() | nil

     

       13
       13
       -
         end

     

       14
       14
       -
       

     

       15
       15
       -
         @doc """

     

       16
       16
       -
         Create a new `Atex.XRPC.Client` from an endpoint, and optionally an

     

       17
       17
       -
         access/refresh token.

     

       18
       18
       -
       

     

       19
       19
       -
         Endpoint should be the base URL of a PDS, or an AppView in the case of

     

       20
       20
       -
         unauthenticated requests (like Bluesky's public API), e.g.

     

       21
       21
       -
         `https://bsky.social`.

     

       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.

     

       22
       10
        
         """

     

       23
       23
       -
         @spec new(String.t()) :: t()

     

       24
       24
       -
         @spec new(String.t(), String.t() | nil) :: t()

     

       25
       25
       -
         @spec new(String.t(), String.t() | nil, String.t() | nil) :: t()

     

       26
       26
       -
         def new(endpoint, access_token \\ nil, refresh_token \\ nil) do

     

       27
       27
       -
           %__MODULE__{endpoint: endpoint, access_token: access_token, refresh_token: refresh_token}

     

       28
       28
       -
         end

     

       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()}

     

       29
       15
        
       

     

       30
       16
        
         @doc """

     

       31
       31
       -
         Create a new `Atex.XRPC.Client` by logging in with an `identifier` and

     

       32
       32
       -
         `password` to fetch an initial pair of access & refresh tokens.

     

       17
       17
       +
         Perform an authenticated HTTP GET request on an XRPC resource.

     

       33
       18
        
       

     

       34
       34
       -
         Uses `com.atproto.server.createSession` under the hood, so `identifier` can be

     

       35
       35
       -
         either a handle or a DID.

     

       36
       36
       -
       

     

       37
       37
       -
         ## Examples

     

       38
       38
       -
       

     

       39
       39
       -
             iex> Atex.XRPC.Client.login("https://bsky.social", "example.com", "password123")

     

       40
       40
       -
             {:ok, %Atex.XRPC.Client{...}}

     

       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.

     

       41
       21
        
         """

     

       42
       42
       -
         @spec login(String.t(), String.t(), String.t()) :: {:ok, t()} | HTTP.Adapter.error()

     

       43
       43
       -
         @spec login(String.t(), String.t(), String.t(), String.t() | nil) ::

     

       44
       44
       -
                 {:ok, t()} | HTTP.Adapter.error()

     

       45
       45
       -
         def login(endpoint, identifier, password, auth_factor_token \\ nil) do

     

       46
       46
       -
           json =

     

       47
       47
       -
             %{identifier: identifier, password: password}

     

       48
       48
       -
             |> then(

     

       49
       49
       -
               &if auth_factor_token do

     

       50
       50
       -
                 Map.merge(&1, %{authFactorToken: auth_factor_token})

     

       51
       51
       -
               else

     

       52
       52
       -
                 &1

     

       53
       53
       -
               end

     

       54
       54
       -
             )

     

       55
       55
       -
       

     

       56
       56
       -
           response = XRPC.unauthed_post(endpoint, "com.atproto.server.createSession", json: json)

     

       57
       57
       -
       

     

       58
       58
       -
           case response do

     

       59
       59
       -
             {:ok, %{"accessJwt" => access_token, "refreshJwt" => refresh_token}} ->

     

       60
       60
       -
               {:ok, new(endpoint, access_token, refresh_token)}

     

       61
       61
       -
       

     

       62
       62
       -
             err ->

     

       63
       63
       -
               err

     

       64
       64
       -
           end

     

       65
       65
       -
         end

     

       22
       22
       +
         @callback get(client(), String.t(), request_opts()) :: request_result()

     

       66
       23
        
       

     

       67
       24
        
         @doc """

     

       68
       68
       -
         Request a new `refresh_token` for the given client.

     

       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.

     

       69
       29
        
         """

     

       70
       70
       -
         @spec refresh(t()) :: {:ok, t()} | HTTP.Adapter.error()

     

       71
       71
       -
         def refresh(%__MODULE__{endpoint: endpoint, refresh_token: refresh_token} = client) do

     

       72
       72
       -
           response =

     

       73
       73
       -
             XRPC.unauthed_post(

     

       74
       74
       -
               endpoint,

     

       75
       75
       -
               "com.atproto.server.refreshSession",

     

       76
       76
       -
               XRPC.put_auth([], refresh_token)

     

       77
       77
       -
             )

     

       78
       78
       -
       

     

       79
       79
       -
           case response do

     

       80
       80
       -
             {:ok, %{"accessJwt" => access_token, "refreshJwt" => refresh_token}} ->

     

       81
       81
       -
               %{client | access_token: access_token, refresh_token: refresh_token}

     

       82
       82
       -
       

     

       83
       83
       -
             err ->

     

       84
       84
       -
               err

     

       85
       85
       -
           end

     

       86
       86
       -
         end

     

       30
       30
       +
         @callback post(client(), String.t(), request_opts()) :: request_result()

     

       87
       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

+181 -38

lib/atex/xrpc.ex

···

       1
       1
        
       defmodule Atex.XRPC do

     

       2
       2
       -
         alias Atex.{HTTP, XRPC}

     

       2
       2
       +
         @moduledoc """

     

       3
       3
       +
         XRPC client module for AT Protocol RPC calls.

     

       3
       4
        
       

     

       4
       4
       -
         # TODO: automatic user-agent, and env for changing it

     

       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`.

     

       5
       8
        
       

     

       6
       6
       -
         # TODO: consistent struct shape/protocol for Lexicon schemas so that user can pass in

     

       7
       7
       -
         # an object (hopefully validated by its module) without needing to specify the

     

       8
       8
       -
         # name & opts separately, and possibly verify the output response against it?

     

       9
       9
       +
         ## Example usage

     

       9
       10
        
       

     

       10
       10
       -
         # TODO: auto refresh, will need to return a client instance in each method.

     

       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

     

       11
       28
        
       

     

       12
       29
        
         @doc """

     

       13
       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
       +
               })

     

       14
       52
        
         """

     

       15
       15
       -
         @spec get(XRPC.Client.t(), String.t(), keyword()) :: HTTP.Adapter.result()

     

       16
       16
       -
         def get(%XRPC.Client{} = client, name, opts \\ []) do

     

       17
       17
       -
           opts = put_auth(opts, client.access_token)

     

       18
       18
       -
           HTTP.get(url(client, name), opts)

     

       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

     

       19
       87
        
         end

     

       20
       88
        
       

     

       21
       89
        
         @doc """

     

       22
       22
       -
         Perform a HTTP POST on a XRPC resource. Called a "prodecure" in lexicons.

     

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

     

       23
       133
        
         """

     

       24
       24
       -
         @spec post(XRPC.Client.t(), String.t(), keyword()) :: HTTP.Adapter.result()

     

       25
       25
       -
         def post(%XRPC.Client{} = client, name, opts \\ []) do

     

       26
       26
       -
           # TODO: look through available HTTP clients and see if they have a

     

       27
       27
       -
           # consistent way of providing JSON bodies with auto content-type. If not,

     

       28
       28
       -
           # create one for adapters.

     

       29
       29
       -
           opts = put_auth(opts, client.access_token)

     

       30
       30
       -
           HTTP.post(url(client, name), opts)

     

       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

     

       31
       180
        
         end

     

       32
       181
        
       

     

       33
       182
        
         @doc """

     

       34
       183
        
         Like `get/3` but is unauthenticated by default.

     

       35
       184
        
         """

     

       36
       36
       -
         @spec unauthed_get(String.t(), String.t(), keyword()) :: HTTP.Adapter.result()

     

       185
       185
       +
         @spec unauthed_get(String.t(), String.t(), keyword()) ::

     

       186
       186
       +
                 {:ok, Req.Response.t()} | {:error, any()}

     

       37
       187
        
         def unauthed_get(endpoint, name, opts \\ []) do

     

       38
       38
       -
           HTTP.get(url(endpoint, name), opts)

     

       188
       188
       +
           Req.get(url(endpoint, name), opts)

     

       39
       189
        
         end

     

       40
       190
        
       

     

       41
       191
        
         @doc """

     

       42
       192
        
         Like `post/3` but is unauthenticated by default.

     

       43
       193
        
         """

     

       44
       44
       -
         @spec unauthed_post(String.t(), String.t(), keyword()) :: HTTP.Adapter.result()

     

       194
       194
       +
         @spec unauthed_post(String.t(), String.t(), keyword()) ::

     

       195
       195
       +
                 {:ok, Req.Response.t()} | {:error, any()}

     

       45
       196
        
         def unauthed_post(endpoint, name, opts \\ []) do

     

       46
       46
       -
           HTTP.post(url(endpoint, name), opts)

     

       197
       197
       +
           Req.post(url(endpoint, name), opts)

     

       47
       198
        
         end

     

       48
       199
        
       

     

       49
       49
       -
         # TODO: use URI module for joining instead?

     

       50
       50
       -
         @spec url(XRPC.Client.t() | String.t(), String.t()) :: String.t()

     

       51
       51
       -
         defp url(%XRPC.Client{endpoint: endpoint}, name), do: url(endpoint, name)

     

       52
       52
       -
         defp url(endpoint, name) when is_binary(endpoint), do: "#{endpoint}/xrpc/#{name}"

     

       200
       200
       +
         @doc """

     

       201
       201
       +
         Create an XRPC url based on an endpoint and a resource name.

     

       202
       202
       +
       

     

       203
       203
       +
         ## Example

     

       53
       204
        
       

     

       54
       54
       -
         @doc """

     

       55
       55
       -
         Put an `authorization` header into a keyword list of options to pass to a HTTP client.

     

       205
       205
       +
             iex> Atex.XRPC.url("https://bsky.app", "app.bsky.actor.getProfile")

     

       206
       206
       +
             "https://bsky.app/xrpc/app.bsky.actor.getProfile"

     

       56
       207
        
         """

     

       57
       57
       -
         @spec put_auth(keyword(), String.t()) :: keyword()

     

       58
       58
       -
         def put_auth(opts, token),

     

       59
       59
       -
           do: put_headers(opts, authorization: "Bearer #{token}")

     

       60
       60
       -
       

     

       61
       61
       -
         @spec put_headers(keyword(), keyword()) :: keyword()

     

       62
       62
       -
         defp put_headers(opts, headers) do

     

       63
       63
       -
           opts

     

       64
       64
       -
           |> Keyword.put_new(:headers, [])

     

       65
       65
       -
           |> Keyword.update(:headers, [], &Keyword.merge(&1, headers))

     

       66
       66
       -
         end

     

       208
       208
       +
         @spec url(String.t(), String.t()) :: String.t()

     

       209
       209
       +
         def url(endpoint, resource) when is_binary(endpoint), do: "#{endpoint}/xrpc/#{resource}"

     

       67
       210
        
       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

+1 -1

lib/mix/tasks/atex.lexicons.ex

···

       44
       44
        
         @aliases [o: :output]

     

       45
       45
        
         @template_path Path.expand("../../../priv/templates/lexicon.eex", __DIR__)

     

       46
       46
        
       

     

       47
       47
       -
         @impl Mix.Task

     

       47
       47
       +
         @impl true

     

       48
       48
        
         def run(args) do

     

       49
       49
        
           {options, globs} = OptionParser.parse!(args, switches: @switches, aliases: @aliases)

     

       50
       50

+16 -4

mix.exs

···

       1
       1
        
       defmodule Atex.MixProject do

     

       2
       2
        
         use Mix.Project

     

       3
       3
        
       

     

       4
       4
       -
         @version "0.4.0"

     

       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
        
       

     
···

       35
       35
        
             {:typedstruct, "~> 0.5"},

     

       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}

     

       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]}

     

       39
       43
        
           ]

     

       40
       44
        
         end

     

       41
       45
        
       

     
···

       50
       54
        
           [

     

       51
       55
        
             extras: [

     

       52
       56
        
               LICENSE: [title: "License"],

     

       53
       53
       -
               "README.md": [title: "Overview"]

     

       57
       57
       +
               "README.md": [title: "Overview"],

     

       58
       58
       +
               "CHANGELOG.md": [title: "Changelog"]

     

       54
       59
        
             ],

     

       55
       60
        
             main: "readme",

     

       56
       61
        
             source_url: @github,

     

       57
       62
        
             source_ref: "v#{@version}",

     

       58
       58
       -
             formatters: ["html"]

     

       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
       +
             ]

     

       59
       71
        
           ]

     

       60
       72
        
         end

     

       61
       73
        
       end

+8 -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"},

     

       2
       3
        
         "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},

     

       3
       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"},

     

       4
       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"},

     

       5
       6
        
         "decimal": {:hex, :decimal, "2.3.0", "3ad6255aa77b4a3c4f818171b12d237500e63525c2fd056699967a3e7ea20f62", [:mix], [], "hexpm", "a4d66355cb29cb47c3cf30e71329e58361cfcb37c34235ef3bf1d7bf3773aeac"},

     

       6
       7
        
         "earmark_parser": {:hex, :earmark_parser, "1.4.44", "f20830dd6b5c77afe2b063777ddbbff09f9759396500cdbe7523efd58d7a339c", [:mix], [], "hexpm", "4778ac752b4701a5599215f7030989c989ffdc4f6df457c5f36938cc2d2a2750"},

     

       7
       7
       -
         "ex_cldr": {:hex, :ex_cldr, "2.42.0", "17ea930e88b8802b330e1c1e288cdbaba52cbfafcccf371ed34b299a47101ffb", [: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", "07264a7225810ecae6bdd6715d8800c037a1248dc0063923cddc4ca3c4888df6"},

     

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

     

       8
       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"},

     

       9
       10
        
         "file_system": {:hex, :file_system, "1.1.0", "08d232062284546c6c34426997dd7ef6ec9f8bbd090eb91780283c9016840e8f", [:mix], [], "hexpm", "bfcf81244f416871f2a2e15c1b515287faa5db9c6bcf290222206d120b3d43f6"},

     

       10
       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"},

     

       11
       12
        
         "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"},

     

       12
       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"},

     

       13
       15
        
         "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},

     

       14
       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"},

     

       15
       17
        
         "makeup_erlang": {:hex, :makeup_erlang, "1.0.2", "03e1804074b3aa64d5fad7aa64601ed0fb395337b982d9bcf04029d68d51b6a7", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "af33ff7ef368d5893e4a267933e7744e46ce3cf1f61e2dccf53a111ed3aa3727"},

     
···

       20
       22
        
         "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},

     

       21
       23
        
         "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"},

     

       22
       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"},

     

       23
       27
        
         "recase": {:hex, :recase, "0.9.0", "437982693fdfbec125f11c8868eb3b4d32e9aa6995d3a68ac8686f3e2bf5d8d1", [:mix], [], "hexpm", "efa7549ebd128988d1723037a6f6a61948055aec107db6288f1c52830cb6501c"},

     

       24
       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"},

     

       25
       29
        
         "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"},

     

       26
       26
       -
         "typedstruct": {:hex, :typedstruct, "0.5.3", "d68ae424251a41b81a8d0c485328ab48edbd3858f3565bbdac21b43c056fc9b4", [:make, :mix], [], "hexpm", "b53b8186701417c0b2782bf02a2db5524f879b8488f91d1d83b97d84c2943432"},

     

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

     

       27
       32
        
         "varint": {:hex, :varint, "1.5.1", "17160c70d0428c3f8a7585e182468cac10bbf165c2360cf2328aaa39d3fb1795", [:mix], [], "hexpm", "24f3deb61e91cb988056de79d06f01161dd01be5e0acae61d8d936a552f1be73"},

     

       33
       33
       +
         "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},

     

       28
       34
        
       }

Compare changes