most of plc.directory's API endpoints

just missing /{did}/data because not sure what it actually does??

src/api.rs

···
+use crate::types::{DidDocument, JsonCid, PlcEntry, PlcOperationType};
+use crate::{ApiContext, db};
+use dropshot::{ClientErrorStatusCode, HttpError, HttpResponseOk, Path, RequestContext, endpoint};
+use ipld_core::cid::Cid;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use std::str::FromStr;
+
+fn err_did_not_found(did: &str) -> HttpError {
+    HttpError::for_not_found(None, format!("DID not registered: {did}"))
+}
+
+fn err_did_tombstoned(did: &str) -> HttpError {
+    HttpError::for_client_error(
+        None,
+        ClientErrorStatusCode::GONE,
+        format!("DID not available: {did}"),
+    )
+}
+
+#[derive(Debug, JsonSchema, Deserialize)]
+pub struct DidPathParams {
+    pub did: String,
+}
+
+#[endpoint {
+    method = GET,
+    path = "/{did}",
+}]
+pub async fn resolve_did(
+    rqctx: RequestContext<ApiContext>,
+    path: Path<DidPathParams>,
+) -> Result<HttpResponseOk<DidDocument>, HttpError> {
+    let conn = rqctx.context().get_conn().await?;
+    let did = path.into_inner().did;
+
+    let op = db::get_latest_operation(&conn, &did)
+        .await
+        .map_err(|v| HttpError::for_internal_error(v.to_string()))?
+        .ok_or(err_did_not_found(&did))?;
+
+    let decoded: PlcOperationType = serde_json::from_value(op.operation)
+        .map_err(|v| HttpError::for_internal_error(v.to_string()))?;
+
+    let doc = match decoded {
+        PlcOperationType::Tombstone(_) => return Err(err_did_tombstoned(&did)),
+        PlcOperationType::Create(op) => DidDocument::from_create(&did, op),
+        PlcOperationType::Operation(op) => DidDocument::from_plc_op(&did, op),
+    };
+
+    Ok(HttpResponseOk(doc))
+}
+
+#[endpoint {
+    method = GET,
+    path = "/{did}/log",
+}]
+pub async fn get_plc_op_log(
+    rqctx: RequestContext<ApiContext>,
+    path: Path<DidPathParams>,
+) -> Result<HttpResponseOk<Vec<PlcOperationType>>, HttpError> {
+    let conn = rqctx.context().get_conn().await?;
+    let did = path.into_inner().did;
+
+    let ops = db::get_operations(&conn, &did)
+        .await
+        .map_err(|v| HttpError::for_internal_error(v.to_string()))?;
+
+    if ops.is_empty() {
+        return Err(err_did_not_found(&did));
+    }
+
+    let ops = ops
+        .into_iter()
+        .map(|op| serde_json::from_value(op.operation))
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|v| HttpError::for_internal_error(v.to_string()))?;
+
+    Ok(HttpResponseOk(ops))
+}
+
+#[endpoint {
+    method = GET,
+    path = "/{did}/log/audit",
+}]
+pub async fn get_plc_audit_log(
+    rqctx: RequestContext<ApiContext>,
+    path: Path<DidPathParams>,
+) -> Result<HttpResponseOk<Vec<PlcEntry>>, HttpError> {
+    let conn = rqctx.context().get_conn().await?;
+    let did = path.into_inner().did;
+
+    let ops = db::get_operations(&conn, &did)
+        .await
+        .map_err(|v| HttpError::for_internal_error(v.to_string()))?;
+
+    if ops.is_empty() {
+        return Err(err_did_not_found(&did));
+    }
+
+    let entries = ops
+        .into_iter()
+        .map(|op| {
+            let operation = serde_json::from_value(op.operation)?;
+            let cid = Cid::from_str(&op.hash).unwrap();
+
+            let entry = PlcEntry {
+                did: did.clone(),
+                operation,
+                cid: JsonCid(cid),
+                nullified: op.nullified,
+                created_at: op.created_at,
+            };
+
+            Ok(entry)
+        })
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|v: eyre::Report| HttpError::for_internal_error(v.to_string()))?;
+
+    Ok(HttpResponseOk(entries))
+}
+
+#[endpoint {
+    method = GET,
+    path = "/{did}/log/last",
+}]
+pub async fn get_last_op(
+    rqctx: RequestContext<ApiContext>,
+    path: Path<DidPathParams>,
+) -> Result<HttpResponseOk<PlcOperationType>, HttpError> {
+    let conn = rqctx.context().get_conn().await?;
+    let did = path.into_inner().did;
+
+    let op = db::get_latest_operation(&conn, &did)
+        .await
+        .map_err(|v| HttpError::for_internal_error(v.to_string()))?
+        .ok_or(err_did_not_found(&did))?;
+
+    let decoded = serde_json::from_value(op.operation)
+        .map_err(|v| HttpError::for_internal_error(v.to_string()))?;
+
+    Ok(HttpResponseOk(decoded))
+}

src/db.rs

···
+use chrono::{DateTime, Utc};
+use deadpool_postgres::Object;
+use serde_json::Value;
+use tokio_postgres::Row;
+
+pub struct Operation {
+    pub did: String,
+    pub hash: String,
+    pub prev: Option<String>,
+    pub sig: String,
+    pub nullified: bool,
+    pub operation: Value,
+    pub created_at: DateTime<Utc>,
+}
+
+impl From<Row> for Operation {
+    fn from(row: Row) -> Self {
+        Operation {
+            did: row.get(0),
+            hash: row.get(1),
+            prev: row.get(2),
+            sig: row.get(3),
+            nullified: row.get(4),
+            operation: row.get(5),
+            created_at: row.get(6),
+        }
+    }
+}
+
+pub async fn get_latest_operation(
+    conn: &Object,
+    did: &str,
+) -> Result<Option<Operation>, tokio_postgres::Error> {
+    let maybe_op = conn
+        .query_opt(
+            "SELECT * FROM operations WHERE did=$1 ORDER BY created_at DESC LIMIT 1",
+            &[&did],
+        )
+        .await?;
+
+    Ok(maybe_op.map(Operation::from))
+}
+
+pub async fn get_operations(
+    conn: &Object,
+    did: &str,
+) -> Result<Vec<Operation>, tokio_postgres::Error> {
+    let ops = conn
+        .query(
+            "SELECT * FROM operations WHERE did=$1 ORDER BY created_at",
+            &[&did],
+        )
+        .await?;
+
+    Ok(ops.into_iter().map(Operation::from).collect())
+}

src/lib.rs

···
-use deadpool_postgres::{Manager, Pool};
-use dropshot::{ApiDescription, ConfigLogging, ConfigLoggingLevel};
+use deadpool_postgres::{Manager, Object, Pool};
+use dropshot::{ApiDescription, ConfigLogging, ConfigLoggingLevel, HttpError};
 use eyre::Context;
 use slog::Logger;
 use std::env::var;
 use std::str::FromStr;
 use tokio_postgres::{Config, NoTls};
 
+mod api;
 mod db;
 pub mod import;
 mod types;
···
     pub pool: Pool,
 }
 
+impl ApiContext {
+    pub async fn get_conn(&self) -> Result<Object, HttpError> {
+        self.pool.get().await.map_err(|err| HttpError::for_internal_error(err.to_string()))
+    }
+}
+
 pub fn create_logger() -> eyre::Result<Logger> {
     let log = ConfigLogging::StderrTerminal { level: ConfigLoggingLevel::Info }
         .to_logger("plc-mirror")?;
···
 }
 
 pub fn create_api() -> eyre::Result<ApiDescription<ApiContext>> {
-    let mut api = ApiDescription::new();
+    let mut api_desc = ApiDescription::new();
 
-    // TODO: api endpoints
+    api_desc.register(api::get_plc_op_log)?;
+    api_desc.register(api::get_plc_audit_log)?;
+    api_desc.register(api::get_last_op)?;
+    api_desc.register(api::resolve_did)?;
 
-    Ok(api)
+    Ok(api_desc)
 }
 
 pub async fn connect_db() -> eyre::Result<Pool> {