Global, mono-binary to libraries and binaries

This separates the previous mono-binary setup into separate libraries
and binaries. Specifically it split the old since api/ingestor binary
into an Atproto, and DB library, as well as an api, and ingestor binary.

Atproto Lib
Was mostly untouched. The original URI implementation was changed to use
FromStr, otherwise only imports were changed.

DB Lib
Is mostly unused, so there wasn't much that needed to be changed. Some
new files were added so that future work on it can hit the ground
running.

Api Binary
Is almost entirely the same. Imports were changed and the ingestor code
of main was removed.

Ingestor Binary
Was almost entirely refactored. An interface to made injestors was
added, and it was modularized. The only shared code is in
Ingestor.start(), and collections.rs's macros, but that is mostly
boilerplate.

db/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "db"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+sqlx = { version = "0.8.6", features = ["postgres", "runtime-tokio"] }
+tokio = "1.45.0"

db/src/connection.rs

@@ -0,0 +1,99 @@
+use sqlx::{
+  query,
+  Database,
+  Pool,
+  Postgres,
+  pool::PoolOptions,
+  postgres::{
+    PgConnectOptions,
+    PgSslMode,
+  },
+  Result,
+};
+use std::string::ToString;
+
+pub struct Db<Dbimp: Database> {
+  pool: Pool<Dbimp>
+}
+
+#[non_exhaustive]
+enum Role {
+  Owner,
+  Participant
+}
+
+impl ToString for Role {
+  fn to_string(&self) -> String {
+    match *self {
+      Role::Owner => "owner".to_string(),
+      Role::Participant => "participant".to_string(),
+    }
+  }
+}
+
+pub struct Session {
+  sessionuri: Uri,
+  label: Option<String>,
+  participants: Vec<Participant>,
+}
+
+impl Db<Postgres> {
+  async fn connect() -> Result<Self> {
+    let conn = PgConnectOptions::new()
+      .host("localhost")
+      .port(5432)
+      .username("postgres")
+      .password("062217")
+      .database("anisky")
+      .ssl_mode(PgSslMode::Disable);
+
+    let pool = match PoolOptions::new().connect_with(conn).await {
+      Ok(p) => p,
+      Err(e) => return Err(e),
+    };
+
+    Ok(Db { pool })
+  }
+  //
+  // pub async fn add_user(&self, user: &User) -> Result<()> {
+  //   query!(r#"
+  //       INSERT INTO users(userdid, handle) VALUES ($1, $2)
+  //     "#,
+  //     user.userdid, user.handle
+  //   ).execute(self.pool).await?;
+  //   Ok(())
+  // }
+  //
+  // pub async fn add_session(&self, session: &Session) -> Result<()> {
+  //   let mut transaction = self.pool.begin().await?;
+  //
+  //   query!(r#"
+  //       INSERT INTO sessions(sessionuri, label) VALUES ($1, $2)
+  //     "#,
+  //     session.sessionuri, session.label
+  //   ).execute(&mut *transaction).await?;
+  //   
+  //   for participant in session.participants {
+  //     query!(r#"
+  //         INSERT INTO participants(sessionuri, userdid, role) VALUES ($1, $2, $3)
+  //       "#,
+  //       session.sessionuri, participant.userdid, participant.role.to_string()
+  //     ).execute(&mut *transaction).await?;
+  //   }
+  //
+  //   transaction.commit().await
+  // }
+  //
+  // pub async fn add_participant(&self, session: Session, 
+  //   participant: Participant) -> Result<Session> {
+  //   query!(r#"
+  //       INSERT INTO participants(sessionuri, userdid, role) VALUES ($1, $2, $3)
+  //     "#,
+  //     session.sessionuri, participant.userdid, participant.role.to_string()
+  //   ).execute(self.pool).await?;
+  //   
+  //   session.participants.push(participant);
+  //
+  //   Ok(session)
+  // }
+}

db/src/interfaces.rs

@@ -0,0 +1,15 @@
+use atproto::{
+    Did,
+    Uri,
+};
+
+pub struct User {
+  userdid: Did,
+  handle: Handle,
+}
+
+struct Participant {
+  participantdid: Did,
+  role: Role,
+}
+

db/src/lib.rs

@@ -0,0 +1 @@
+pub struct db;