+26

migrations/2025-05-15-182818_init_diff/down.sql

··· 1 1 + -- This file should undo anything in `up.sql` 2 2 + DROP TABLE IF EXISTS `oauth_refresh_tokens`; 3 3 + DROP TABLE IF EXISTS `repo_seq`; 4 4 + DROP TABLE IF EXISTS `blob`; 5 5 + DROP TABLE IF EXISTS `oauth_used_jtis`; 6 6 + DROP TABLE IF EXISTS `app_password`; 7 7 + DROP TABLE IF EXISTS `repo_block`; 8 8 + DROP TABLE IF EXISTS `device_account`; 9 9 + DROP TABLE IF EXISTS `backlink`; 10 10 + DROP TABLE IF EXISTS `actor`; 11 11 + DROP TABLE IF EXISTS `device`; 12 12 + DROP TABLE IF EXISTS `did_doc`; 13 13 + DROP TABLE IF EXISTS `email_token`; 14 14 + DROP TABLE IF EXISTS `invite_code`; 15 15 + DROP TABLE IF EXISTS `oauth_par_requests`; 16 16 + DROP TABLE IF EXISTS `record`; 17 17 + DROP TABLE IF EXISTS `repo_root`; 18 18 + DROP TABLE IF EXISTS `used_refresh_token`; 19 19 + DROP TABLE IF EXISTS `invite_code_use`; 20 20 + DROP TABLE IF EXISTS `oauth_authorization_codes`; 21 21 + DROP TABLE IF EXISTS `authorization_request`; 22 22 + DROP TABLE IF EXISTS `token`; 23 23 + DROP TABLE IF EXISTS `refresh_token`; 24 24 + DROP TABLE IF EXISTS `account_pref`; 25 25 + DROP TABLE IF EXISTS `record_blob`; 26 26 + DROP TABLE IF EXISTS `account`;

+230

migrations/2025-05-15-182818_init_diff/up.sql

··· 1 1 + CREATE TABLE `oauth_refresh_tokens`( 2 2 + `token` VARCHAR NOT NULL PRIMARY KEY, 3 3 + `client_id` VARCHAR NOT NULL, 4 4 + `subject` VARCHAR NOT NULL, 5 5 + `dpop_thumbprint` VARCHAR NOT NULL, 6 6 + `scope` VARCHAR, 7 7 + `created_at` INT8 NOT NULL, 8 8 + `expires_at` INT8 NOT NULL, 9 9 + `revoked` BOOL NOT NULL 10 10 + ); 11 11 + 12 12 + CREATE TABLE `repo_seq`( 13 13 + `seq` INT8 NOT NULL PRIMARY KEY, 14 14 + `did` VARCHAR NOT NULL, 15 15 + `eventtype` VARCHAR NOT NULL, 16 16 + `event` BYTEA NOT NULL, 17 17 + `invalidated` INT2 NOT NULL, 18 18 + `sequencedat` VARCHAR NOT NULL 19 19 + ); 20 20 + 21 21 + CREATE TABLE `blob`( 22 22 + `cid` VARCHAR NOT NULL, 23 23 + `did` VARCHAR NOT NULL, 24 24 + `mimetype` VARCHAR NOT NULL, 25 25 + `size` INT4 NOT NULL, 26 26 + `tempkey` VARCHAR, 27 27 + `width` INT4, 28 28 + `height` INT4, 29 29 + `createdat` VARCHAR NOT NULL, 30 30 + `takedownref` VARCHAR, 31 31 + PRIMARY KEY(`cid`, `did`) 32 32 + ); 33 33 + 34 34 + CREATE TABLE `oauth_used_jtis`( 35 35 + `jti` VARCHAR NOT NULL PRIMARY KEY, 36 36 + `issuer` VARCHAR NOT NULL, 37 37 + `created_at` INT8 NOT NULL, 38 38 + `expires_at` INT8 NOT NULL 39 39 + ); 40 40 + 41 41 + CREATE TABLE `app_password`( 42 42 + `did` VARCHAR NOT NULL, 43 43 + `name` VARCHAR NOT NULL, 44 44 + `password` VARCHAR NOT NULL, 45 45 + `createdat` VARCHAR NOT NULL, 46 46 + PRIMARY KEY(`did`, `name`) 47 47 + ); 48 48 + 49 49 + CREATE TABLE `repo_block`( 50 50 + `cid` VARCHAR NOT NULL, 51 51 + `did` VARCHAR NOT NULL, 52 52 + `reporev` VARCHAR NOT NULL, 53 53 + `size` INT4 NOT NULL, 54 54 + `content` BYTEA NOT NULL, 55 55 + PRIMARY KEY(`cid`, `did`) 56 56 + ); 57 57 + 58 58 + CREATE TABLE `device_account`( 59 59 + `did` VARCHAR NOT NULL, 60 60 + `deviceid` VARCHAR NOT NULL, 61 61 + `authenticatedat` TIMESTAMPTZ NOT NULL, 62 62 + `remember` BOOL NOT NULL, 63 63 + `authorizedclients` VARCHAR NOT NULL, 64 64 + PRIMARY KEY(`deviceId`, `did`) 65 65 + ); 66 66 + 67 67 + CREATE TABLE `backlink`( 68 68 + `uri` VARCHAR NOT NULL, 69 69 + `path` VARCHAR NOT NULL, 70 70 + `linkto` VARCHAR NOT NULL, 71 71 + PRIMARY KEY(`uri`, `path`) 72 72 + ); 73 73 + 74 74 + CREATE TABLE `actor`( 75 75 + `did` VARCHAR NOT NULL PRIMARY KEY, 76 76 + `handle` VARCHAR, 77 77 + `createdat` VARCHAR NOT NULL, 78 78 + `takedownref` VARCHAR, 79 79 + `deactivatedat` VARCHAR, 80 80 + `deleteafter` VARCHAR 81 81 + ); 82 82 + 83 83 + CREATE TABLE `device`( 84 84 + `id` VARCHAR NOT NULL PRIMARY KEY, 85 85 + `sessionid` VARCHAR, 86 86 + `useragent` VARCHAR, 87 87 + `ipaddress` VARCHAR NOT NULL, 88 88 + `lastseenat` TIMESTAMPTZ NOT NULL 89 89 + ); 90 90 + 91 91 + CREATE TABLE `did_doc`( 92 92 + `did` VARCHAR NOT NULL PRIMARY KEY, 93 93 + `doc` TEXT NOT NULL, 94 94 + `updatedat` INT8 NOT NULL 95 95 + ); 96 96 + 97 97 + CREATE TABLE `email_token`( 98 98 + `purpose` VARCHAR NOT NULL, 99 99 + `did` VARCHAR NOT NULL, 100 100 + `token` VARCHAR NOT NULL, 101 101 + `requestedat` VARCHAR NOT NULL, 102 102 + PRIMARY KEY(`purpose`, `did`) 103 103 + ); 104 104 + 105 105 + CREATE TABLE `invite_code`( 106 106 + `code` VARCHAR NOT NULL PRIMARY KEY, 107 107 + `availableuses` INT4 NOT NULL, 108 108 + `disabled` INT2 NOT NULL, 109 109 + `foraccount` VARCHAR NOT NULL, 110 110 + `createdby` VARCHAR NOT NULL, 111 111 + `createdat` VARCHAR NOT NULL 112 112 + ); 113 113 + 114 114 + CREATE TABLE `oauth_par_requests`( 115 115 + `request_uri` VARCHAR NOT NULL PRIMARY KEY, 116 116 + `client_id` VARCHAR NOT NULL, 117 117 + `response_type` VARCHAR NOT NULL, 118 118 + `code_challenge` VARCHAR NOT NULL, 119 119 + `code_challenge_method` VARCHAR NOT NULL, 120 120 + `state` VARCHAR, 121 121 + `login_hint` VARCHAR, 122 122 + `scope` VARCHAR, 123 123 + `redirect_uri` VARCHAR, 124 124 + `response_mode` VARCHAR, 125 125 + `display` VARCHAR, 126 126 + `created_at` INT8 NOT NULL, 127 127 + `expires_at` INT8 NOT NULL 128 128 + ); 129 129 + 130 130 + CREATE TABLE `record`( 131 131 + `uri` VARCHAR NOT NULL PRIMARY KEY, 132 132 + `cid` VARCHAR NOT NULL, 133 133 + `did` VARCHAR NOT NULL, 134 134 + `collection` VARCHAR NOT NULL, 135 135 + `rkey` VARCHAR NOT NULL, 136 136 + `reporev` VARCHAR, 137 137 + `indexedat` VARCHAR NOT NULL, 138 138 + `takedownref` VARCHAR 139 139 + ); 140 140 + 141 141 + CREATE TABLE `repo_root`( 142 142 + `did` VARCHAR NOT NULL PRIMARY KEY, 143 143 + `cid` VARCHAR NOT NULL, 144 144 + `rev` VARCHAR NOT NULL, 145 145 + `indexedat` VARCHAR NOT NULL 146 146 + ); 147 147 + 148 148 + CREATE TABLE `used_refresh_token`( 149 149 + `refreshtoken` VARCHAR NOT NULL PRIMARY KEY, 150 150 + `tokenid` VARCHAR NOT NULL 151 151 + ); 152 152 + 153 153 + CREATE TABLE `invite_code_use`( 154 154 + `code` VARCHAR NOT NULL, 155 155 + `usedby` VARCHAR NOT NULL, 156 156 + `usedat` VARCHAR NOT NULL, 157 157 + PRIMARY KEY(`code`, `usedBy`) 158 158 + ); 159 159 + 160 160 + CREATE TABLE `oauth_authorization_codes`( 161 161 + `code` VARCHAR NOT NULL PRIMARY KEY, 162 162 + `client_id` VARCHAR NOT NULL, 163 163 + `subject` VARCHAR NOT NULL, 164 164 + `code_challenge` VARCHAR NOT NULL, 165 165 + `code_challenge_method` VARCHAR NOT NULL, 166 166 + `redirect_uri` VARCHAR NOT NULL, 167 167 + `scope` VARCHAR, 168 168 + `created_at` INT8 NOT NULL, 169 169 + `expires_at` INT8 NOT NULL, 170 170 + `used` BOOL NOT NULL 171 171 + ); 172 172 + 173 173 + CREATE TABLE `authorization_request`( 174 174 + `id` VARCHAR NOT NULL PRIMARY KEY, 175 175 + `did` VARCHAR, 176 176 + `deviceid` VARCHAR, 177 177 + `clientid` VARCHAR NOT NULL, 178 178 + `clientauth` VARCHAR NOT NULL, 179 179 + `parameters` VARCHAR NOT NULL, 180 180 + `expiresat` TIMESTAMPTZ NOT NULL, 181 181 + `code` VARCHAR 182 182 + ); 183 183 + 184 184 + CREATE TABLE `token`( 185 185 + `id` VARCHAR NOT NULL PRIMARY KEY, 186 186 + `did` VARCHAR NOT NULL, 187 187 + `tokenid` VARCHAR NOT NULL, 188 188 + `createdat` TIMESTAMPTZ NOT NULL, 189 189 + `updatedat` TIMESTAMPTZ NOT NULL, 190 190 + `expiresat` TIMESTAMPTZ NOT NULL, 191 191 + `clientid` VARCHAR NOT NULL, 192 192 + `clientauth` VARCHAR NOT NULL, 193 193 + `deviceid` VARCHAR, 194 194 + `parameters` VARCHAR NOT NULL, 195 195 + `details` VARCHAR, 196 196 + `code` VARCHAR, 197 197 + `currentrefreshtoken` VARCHAR 198 198 + ); 199 199 + 200 200 + CREATE TABLE `refresh_token`( 201 201 + `id` VARCHAR NOT NULL PRIMARY KEY, 202 202 + `did` VARCHAR NOT NULL, 203 203 + `expiresat` VARCHAR NOT NULL, 204 204 + `nextid` VARCHAR, 205 205 + `apppasswordname` VARCHAR 206 206 + ); 207 207 + 208 208 + CREATE TABLE `account_pref`( 209 209 + `id` INT4 NOT NULL PRIMARY KEY, 210 210 + `did` VARCHAR NOT NULL, 211 211 + `name` VARCHAR NOT NULL, 212 212 + `valuejson` TEXT 213 213 + ); 214 214 + 215 215 + CREATE TABLE `record_blob`( 216 216 + `blobcid` VARCHAR NOT NULL, 217 217 + `recorduri` VARCHAR NOT NULL, 218 218 + `did` VARCHAR NOT NULL, 219 219 + PRIMARY KEY(`blobCid`, `recordUri`) 220 220 + ); 221 221 + 222 222 + CREATE TABLE `account`( 223 223 + `did` VARCHAR NOT NULL PRIMARY KEY, 224 224 + `email` VARCHAR NOT NULL, 225 225 + `recoverykey` VARCHAR, 226 226 + `password` VARCHAR NOT NULL, 227 227 + `createdat` VARCHAR NOT NULL, 228 228 + `invitesdisabled` INT2 NOT NULL, 229 229 + `emailconfirmedat` VARCHAR 230 230 + );

+601

src/models.rs

··· 1 1 + // Generated by diesel_ext 2 2 + 3 3 + #![allow(unused, non_snake_case)] 4 4 + #![allow(clippy::all)] 5 5 + 6 6 + pub mod pds { 7 7 + 8 8 + use anyhow::{Result, bail}; 9 9 + use chrono::DateTime; 10 10 + use chrono::offset::Utc; 11 11 + use diesel::backend::Backend; 12 12 + use diesel::deserialize::FromSql; 13 13 + use diesel::prelude::*; 14 14 + use diesel::serialize::{Output, ToSql}; 15 15 + use diesel::sql_types::Text; 16 16 + use diesel::sqlite::Sqlite; 17 17 + use diesel::*; 18 18 + use serde::{Deserialize, Serialize}; 19 19 + 20 20 + #[derive( 21 21 + Queryable, 22 22 + Identifiable, 23 23 + Selectable, 24 24 + Clone, 25 25 + Debug, 26 26 + PartialEq, 27 27 + Default, 28 28 + Serialize, 29 29 + Deserialize, 30 30 + )] 31 31 + #[diesel(primary_key(request_uri))] 32 32 + #[diesel(table_name = crate::schema::pds::oauth_par_requests)] 33 33 + #[diesel(check_for_backend(Sqlite))] 34 34 + pub struct OauthParRequest { 35 35 + pub request_uri: String, 36 36 + pub client_id: String, 37 37 + pub response_type: String, 38 38 + pub code_challenge: String, 39 39 + pub code_challenge_method: String, 40 40 + pub state: Option<String>, 41 41 + pub login_hint: Option<String>, 42 42 + pub scope: Option<String>, 43 43 + pub redirect_uri: Option<String>, 44 44 + pub response_mode: Option<String>, 45 45 + pub display: Option<String>, 46 46 + pub created_at: i64, 47 47 + pub expires_at: i64, 48 48 + } 49 49 + 50 50 + #[derive( 51 51 + Queryable, 52 52 + Identifiable, 53 53 + Selectable, 54 54 + Clone, 55 55 + Debug, 56 56 + PartialEq, 57 57 + Default, 58 58 + Serialize, 59 59 + Deserialize, 60 60 + )] 61 61 + #[diesel(primary_key(code))] 62 62 + #[diesel(table_name = crate::schema::pds::oauth_authorization_codes)] 63 63 + #[diesel(check_for_backend(Sqlite))] 64 64 + pub struct OauthAuthorizationCode { 65 65 + pub code: String, 66 66 + pub client_id: String, 67 67 + pub subject: String, 68 68 + pub code_challenge: String, 69 69 + pub code_challenge_method: String, 70 70 + pub redirect_uri: String, 71 71 + pub scope: Option<String>, 72 72 + pub created_at: i64, 73 73 + pub expires_at: i64, 74 74 + pub used: bool, 75 75 + } 76 76 + 77 77 + #[derive( 78 78 + Queryable, 79 79 + Identifiable, 80 80 + Selectable, 81 81 + Clone, 82 82 + Debug, 83 83 + PartialEq, 84 84 + Default, 85 85 + Serialize, 86 86 + Deserialize, 87 87 + )] 88 88 + #[diesel(primary_key(token))] 89 89 + #[diesel(table_name = crate::schema::pds::oauth_refresh_tokens)] 90 90 + #[diesel(check_for_backend(Sqlite))] 91 91 + pub struct OauthRefreshToken { 92 92 + pub token: String, 93 93 + pub client_id: String, 94 94 + pub subject: String, 95 95 + pub dpop_thumbprint: String, 96 96 + pub scope: Option<String>, 97 97 + pub created_at: i64, 98 98 + pub expires_at: i64, 99 99 + pub revoked: bool, 100 100 + } 101 101 + 102 102 + #[derive( 103 103 + Queryable, 104 104 + Identifiable, 105 105 + Selectable, 106 106 + Clone, 107 107 + Debug, 108 108 + PartialEq, 109 109 + Default, 110 110 + Serialize, 111 111 + Deserialize, 112 112 + )] 113 113 + #[diesel(primary_key(jti))] 114 114 + #[diesel(table_name = crate::schema::pds::oauth_used_jtis)] 115 115 + #[diesel(check_for_backend(Sqlite))] 116 116 + pub struct OauthUsedJti { 117 117 + pub jti: String, 118 118 + pub issuer: String, 119 119 + pub created_at: i64, 120 120 + pub expires_at: i64, 121 121 + } 122 122 + 123 123 + #[derive( 124 124 + Queryable, 125 125 + Identifiable, 126 126 + Selectable, 127 127 + Clone, 128 128 + Debug, 129 129 + PartialEq, 130 130 + Default, 131 131 + Serialize, 132 132 + Deserialize, 133 133 + )] 134 134 + #[diesel(primary_key(did))] 135 135 + #[diesel(table_name = crate::schema::pds::account)] 136 136 + #[diesel(check_for_backend(Sqlite))] 137 137 + pub struct Account { 138 138 + pub did: String, 139 139 + pub email: String, 140 140 + #[diesel(column_name = recoveryKey)] 141 141 + #[serde(rename = "recoveryKey")] 142 142 + pub recovery_key: Option<String>, 143 143 + pub password: String, 144 144 + #[diesel(column_name = createdAt)] 145 145 + #[serde(rename = "createdAt")] 146 146 + pub created_at: String, 147 147 + #[diesel(column_name = invitesDisabled)] 148 148 + #[serde(rename = "invitesDisabled")] 149 149 + pub invites_disabled: i16, 150 150 + #[diesel(column_name = emailConfirmedAt)] 151 151 + #[serde(rename = "emailConfirmedAt")] 152 152 + pub email_confirmed_at: Option<String>, 153 153 + } 154 154 + 155 155 + #[derive( 156 156 + Queryable, 157 157 + Identifiable, 158 158 + Selectable, 159 159 + Clone, 160 160 + Debug, 161 161 + PartialEq, 162 162 + Default, 163 163 + Serialize, 164 164 + Deserialize, 165 165 + )] 166 166 + #[diesel(table_name = crate::schema::pds::account_pref)] 167 167 + #[diesel(check_for_backend(Sqlite))] 168 168 + pub struct AccountPref { 169 169 + pub id: i32, 170 170 + pub did: String, 171 171 + pub name: String, 172 172 + pub valueJson: Option<String>, 173 173 + } 174 174 + 175 175 + #[derive( 176 176 + Queryable, 177 177 + Identifiable, 178 178 + Selectable, 179 179 + Clone, 180 180 + Debug, 181 181 + PartialEq, 182 182 + Default, 183 183 + Serialize, 184 184 + Deserialize, 185 185 + )] 186 186 + #[diesel(primary_key(did))] 187 187 + #[diesel(table_name = crate::schema::pds::actor)] 188 188 + #[diesel(check_for_backend(Sqlite))] 189 189 + pub struct Actor { 190 190 + pub did: String, 191 191 + pub handle: Option<String>, 192 192 + pub createdAt: String, 193 193 + pub takedownRef: Option<String>, 194 194 + pub deactivatedAt: Option<String>, 195 195 + pub deleteAfter: Option<String>, 196 196 + } 197 197 + 198 198 + #[derive( 199 199 + Queryable, 200 200 + Identifiable, 201 201 + Selectable, 202 202 + Clone, 203 203 + Debug, 204 204 + PartialEq, 205 205 + Default, 206 206 + Serialize, 207 207 + Deserialize, 208 208 + )] 209 209 + #[diesel(primary_key(did, name))] 210 210 + #[diesel(table_name = crate::schema::pds::app_password)] 211 211 + #[diesel(check_for_backend(Sqlite))] 212 212 + pub struct AppPassword { 213 213 + pub did: String, 214 214 + pub name: String, 215 215 + pub password: String, 216 216 + pub createdAt: String, 217 217 + } 218 218 + 219 219 + #[derive( 220 220 + Queryable, 221 221 + Identifiable, 222 222 + Selectable, 223 223 + Clone, 224 224 + Debug, 225 225 + PartialEq, 226 226 + Default, 227 227 + Serialize, 228 228 + Deserialize, 229 229 + )] 230 230 + #[diesel(table_name = crate::schema::pds::authorization_request)] 231 231 + #[diesel(check_for_backend(Sqlite))] 232 232 + pub struct AuthorizationRequest { 233 233 + pub id: String, 234 234 + pub did: Option<String>, 235 235 + pub deviceId: Option<String>, 236 236 + pub clientId: String, 237 237 + pub clientAuth: String, 238 238 + pub parameters: String, 239 239 + pub expiresAt: DateTime<Utc>, 240 240 + pub code: Option<String>, 241 241 + } 242 242 + 243 243 + #[derive( 244 244 + Queryable, 245 245 + Identifiable, 246 246 + Selectable, 247 247 + Clone, 248 248 + Debug, 249 249 + PartialEq, 250 250 + Default, 251 251 + Serialize, 252 252 + Deserialize, 253 253 + )] 254 254 + #[diesel(primary_key(uri, path))] 255 255 + #[diesel(table_name = crate::schema::pds::backlink)] 256 256 + #[diesel(check_for_backend(Sqlite))] 257 257 + pub struct Backlink { 258 258 + pub uri: String, 259 259 + pub path: String, 260 260 + pub linkTo: String, 261 261 + } 262 262 + 263 263 + #[derive( 264 264 + Queryable, 265 265 + Identifiable, 266 266 + Selectable, 267 267 + Clone, 268 268 + Debug, 269 269 + PartialEq, 270 270 + Default, 271 271 + Serialize, 272 272 + Deserialize, 273 273 + )] 274 274 + #[diesel(primary_key(cid, did))] 275 275 + #[diesel(table_name = crate::schema::pds::blob)] 276 276 + #[diesel(check_for_backend(Sqlite))] 277 277 + pub struct Blob { 278 278 + pub cid: String, 279 279 + pub did: String, 280 280 + pub mimeType: String, 281 281 + pub size: i32, 282 282 + pub tempKey: Option<String>, 283 283 + pub width: Option<i32>, 284 284 + pub height: Option<i32>, 285 285 + pub createdAt: String, 286 286 + pub takedownRef: Option<String>, 287 287 + } 288 288 + 289 289 + #[derive( 290 290 + Queryable, 291 291 + Identifiable, 292 292 + Selectable, 293 293 + Clone, 294 294 + Debug, 295 295 + PartialEq, 296 296 + Default, 297 297 + Serialize, 298 298 + Deserialize, 299 299 + )] 300 300 + #[diesel(table_name = crate::schema::pds::device)] 301 301 + #[diesel(check_for_backend(Sqlite))] 302 302 + pub struct Device { 303 303 + pub id: String, 304 304 + pub sessionId: Option<String>, 305 305 + pub userAgent: Option<String>, 306 306 + pub ipAddress: String, 307 307 + pub lastSeenAt: DateTime<Utc>, 308 308 + } 309 309 + 310 310 + #[derive( 311 311 + Queryable, 312 312 + Identifiable, 313 313 + Selectable, 314 314 + Clone, 315 315 + Debug, 316 316 + PartialEq, 317 317 + Default, 318 318 + Serialize, 319 319 + Deserialize, 320 320 + )] 321 321 + #[diesel(primary_key(deviceId, did))] 322 322 + #[diesel(table_name = crate::schema::pds::device_account)] 323 323 + #[diesel(check_for_backend(Sqlite))] 324 324 + pub struct DeviceAccount { 325 325 + pub did: String, 326 326 + pub deviceId: String, 327 327 + pub authenticatedAt: DateTime<Utc>, 328 328 + pub remember: bool, 329 329 + pub authorizedClients: String, 330 330 + } 331 331 + 332 332 + #[derive( 333 333 + Queryable, 334 334 + Identifiable, 335 335 + Selectable, 336 336 + Clone, 337 337 + Debug, 338 338 + PartialEq, 339 339 + Default, 340 340 + Serialize, 341 341 + Deserialize, 342 342 + )] 343 343 + #[diesel(primary_key(did))] 344 344 + #[diesel(table_name = crate::schema::pds::did_doc)] 345 345 + #[diesel(check_for_backend(Sqlite))] 346 346 + pub struct DidDoc { 347 347 + pub did: String, 348 348 + pub doc: String, 349 349 + pub updatedAt: i64, 350 350 + } 351 351 + 352 352 + #[derive( 353 353 + Queryable, 354 354 + Identifiable, 355 355 + Selectable, 356 356 + Clone, 357 357 + Debug, 358 358 + PartialEq, 359 359 + Default, 360 360 + Serialize, 361 361 + Deserialize, 362 362 + )] 363 363 + #[diesel(primary_key(purpose, did))] 364 364 + #[diesel(table_name = crate::schema::pds::email_token)] 365 365 + #[diesel(check_for_backend(Sqlite))] 366 366 + pub struct EmailToken { 367 367 + pub purpose: String, 368 368 + pub did: String, 369 369 + pub token: String, 370 370 + pub requestedAt: String, 371 371 + } 372 372 + 373 373 + #[derive( 374 374 + Queryable, 375 375 + Identifiable, 376 376 + Selectable, 377 377 + Clone, 378 378 + Debug, 379 379 + PartialEq, 380 380 + Default, 381 381 + Serialize, 382 382 + Deserialize, 383 383 + )] 384 384 + #[diesel(primary_key(code))] 385 385 + #[diesel(table_name = crate::schema::pds::invite_code)] 386 386 + #[diesel(check_for_backend(Sqlite))] 387 387 + pub struct InviteCode { 388 388 + pub code: String, 389 389 + pub availableUses: i32, 390 390 + pub disabled: i16, 391 391 + pub forAccount: String, 392 392 + pub createdBy: String, 393 393 + pub createdAt: String, 394 394 + } 395 395 + 396 396 + #[derive( 397 397 + Queryable, 398 398 + Identifiable, 399 399 + Selectable, 400 400 + Clone, 401 401 + Debug, 402 402 + PartialEq, 403 403 + Default, 404 404 + Serialize, 405 405 + Deserialize, 406 406 + )] 407 407 + #[diesel(primary_key(code, usedBy))] 408 408 + #[diesel(table_name = crate::schema::pds::invite_code_use)] 409 409 + #[diesel(check_for_backend(Sqlite))] 410 410 + pub struct InviteCodeUse { 411 411 + pub code: String, 412 412 + pub usedBy: String, 413 413 + pub usedAt: String, 414 414 + } 415 415 + 416 416 + #[derive( 417 417 + Queryable, 418 418 + Identifiable, 419 419 + Selectable, 420 420 + Clone, 421 421 + Debug, 422 422 + PartialEq, 423 423 + Default, 424 424 + Serialize, 425 425 + Deserialize, 426 426 + )] 427 427 + #[diesel(primary_key(uri))] 428 428 + #[diesel(table_name = crate::schema::pds::record)] 429 429 + #[diesel(check_for_backend(Sqlite))] 430 430 + pub struct Record { 431 431 + pub uri: String, 432 432 + pub cid: String, 433 433 + pub did: String, 434 434 + pub collection: String, 435 435 + pub rkey: String, 436 436 + pub repoRev: Option<String>, 437 437 + pub indexedAt: String, 438 438 + pub takedownRef: Option<String>, 439 439 + } 440 440 + 441 441 + #[derive( 442 442 + Queryable, 443 443 + Identifiable, 444 444 + Selectable, 445 445 + Clone, 446 446 + Debug, 447 447 + PartialEq, 448 448 + Default, 449 449 + Serialize, 450 450 + Deserialize, 451 451 + )] 452 452 + #[diesel(primary_key(blobCid, recordUri))] 453 453 + #[diesel(table_name = crate::schema::pds::record_blob)] 454 454 + #[diesel(check_for_backend(Sqlite))] 455 455 + pub struct RecordBlob { 456 456 + pub blobCid: String, 457 457 + pub recordUri: String, 458 458 + pub did: String, 459 459 + } 460 460 + 461 461 + #[derive( 462 462 + Queryable, 463 463 + Identifiable, 464 464 + Selectable, 465 465 + Clone, 466 466 + Debug, 467 467 + PartialEq, 468 468 + Default, 469 469 + Serialize, 470 470 + Deserialize, 471 471 + )] 472 472 + #[diesel(table_name = crate::schema::pds::refresh_token)] 473 473 + #[diesel(check_for_backend(Sqlite))] 474 474 + pub struct RefreshToken { 475 475 + pub id: String, 476 476 + pub did: String, 477 477 + #[diesel(column_name = expiresAt)] 478 478 + #[serde(rename = "expiresAt")] 479 479 + pub expires_at: String, 480 480 + #[diesel(column_name = nextId)] 481 481 + #[serde(rename = "nextId")] 482 482 + pub next_id: Option<String>, 483 483 + #[diesel(column_name = appPasswordName)] 484 484 + #[serde(rename = "appPasswordName")] 485 485 + pub app_password_name: Option<String>, 486 486 + } 487 487 + 488 488 + #[derive( 489 489 + Queryable, 490 490 + Identifiable, 491 491 + Selectable, 492 492 + Clone, 493 493 + Debug, 494 494 + PartialEq, 495 495 + Default, 496 496 + Serialize, 497 497 + Deserialize, 498 498 + )] 499 499 + #[diesel(primary_key(cid, did))] 500 500 + #[diesel(table_name = crate::schema::pds::repo_block)] 501 501 + #[diesel(check_for_backend(Sqlite))] 502 502 + pub struct RepoBlock { 503 503 + pub cid: String, 504 504 + pub did: String, 505 505 + pub repoRev: String, 506 506 + pub size: i32, 507 507 + pub content: Vec<u8>, 508 508 + } 509 509 + 510 510 + #[derive( 511 511 + Queryable, 512 512 + Identifiable, 513 513 + Selectable, 514 514 + Clone, 515 515 + Debug, 516 516 + PartialEq, 517 517 + Default, 518 518 + Serialize, 519 519 + Deserialize, 520 520 + )] 521 521 + #[diesel(primary_key(did))] 522 522 + #[diesel(table_name = crate::schema::pds::repo_root)] 523 523 + #[diesel(check_for_backend(Sqlite))] 524 524 + pub struct RepoRoot { 525 525 + pub did: String, 526 526 + pub cid: String, 527 527 + pub rev: String, 528 528 + pub indexedAt: String, 529 529 + } 530 530 + 531 531 + #[derive( 532 532 + Queryable, 533 533 + Identifiable, 534 534 + Selectable, 535 535 + Clone, 536 536 + Debug, 537 537 + PartialEq, 538 538 + Default, 539 539 + Serialize, 540 540 + Deserialize, 541 541 + )] 542 542 + #[diesel(primary_key(seq))] 543 543 + #[diesel(table_name = crate::schema::pds::repo_seq)] 544 544 + #[diesel(check_for_backend(Sqlite))] 545 545 + pub struct RepoSeq { 546 546 + pub seq: i64, 547 547 + pub did: String, 548 548 + pub eventType: String, 549 549 + pub event: Vec<u8>, 550 550 + pub invalidated: i16, 551 551 + pub sequencedAt: String, 552 552 + } 553 553 + 554 554 + #[derive( 555 555 + Queryable, 556 556 + Identifiable, 557 557 + Selectable, 558 558 + Clone, 559 559 + Debug, 560 560 + PartialEq, 561 561 + Default, 562 562 + Serialize, 563 563 + Deserialize, 564 564 + )] 565 565 + #[diesel(table_name = crate::schema::pds::token)] 566 566 + #[diesel(check_for_backend(Sqlite))] 567 567 + pub struct Token { 568 568 + pub id: String, 569 569 + pub did: String, 570 570 + pub tokenId: String, 571 571 + pub createdAt: DateTime<Utc>, 572 572 + pub updatedAt: DateTime<Utc>, 573 573 + pub expiresAt: DateTime<Utc>, 574 574 + pub clientId: String, 575 575 + pub clientAuth: String, 576 576 + pub deviceId: Option<String>, 577 577 + pub parameters: String, 578 578 + pub details: Option<String>, 579 579 + pub code: Option<String>, 580 580 + pub currentRefreshToken: Option<String>, 581 581 + } 582 582 + 583 583 + #[derive( 584 584 + Queryable, 585 585 + Identifiable, 586 586 + Selectable, 587 587 + Clone, 588 588 + Debug, 589 589 + PartialEq, 590 590 + Default, 591 591 + Serialize, 592 592 + Deserialize, 593 593 + )] 594 594 + #[diesel(primary_key(refreshToken))] 595 595 + #[diesel(table_name = crate::schema::pds::used_refresh_token)] 596 596 + #[diesel(check_for_backend(Sqlite))] 597 597 + pub struct UsedRefreshToken { 598 598 + pub refreshToken: String, 599 599 + pub tokenId: String, 600 600 + } 601 601 + }