+5

app/api/inngest/client.ts

··· 21 21 }; 22 22 }; 23 23 "appview/come-online": { data: {} }; 24 24 + "user/migrate-to-standard": { 25 25 + data: { 26 26 + did: string; 27 27 + }; 28 28 + }; 24 29 }; 25 30 26 31 // Create a client to send and receive events

+3 -1

app/api/inngest/functions/index_post_mention.ts

··· 55 55 authorDid = did; 56 56 } else { 57 57 // Publication post: look up by custom domain 58 58 + // Support both old format (pub.leaflet.publication with base_path) and 59 59 + // new format (site.standard.publication with url as https://domain) 58 60 let { data: pub, error } = await supabaseServerClient 59 61 .from("publications") 60 62 .select("*") 61 61 - .eq("record->>base_path", url.host) 63 63 + .or(`record->>base_path.eq.${url.host},record->>url.eq.https://${url.host}`) 62 64 .single(); 63 65 64 66 if (!pub) {

+427

app/api/inngest/functions/migrate_user_to_standard.ts

··· 1 1 + import { supabaseServerClient } from "supabase/serverClient"; 2 2 + import { inngest } from "../client"; 3 3 + import { restoreOAuthSession } from "src/atproto-oauth"; 4 4 + import { AtpBaseClient, SiteStandardPublication, SiteStandardDocument, SiteStandardGraphSubscription } from "lexicons/api"; 5 5 + import { AtUri } from "@atproto/syntax"; 6 6 + import { Json } from "supabase/database.types"; 7 7 + import { normalizePublicationRecord, normalizeDocumentRecord } from "src/utils/normalizeRecords"; 8 8 + 9 9 + type MigrationResult = 10 10 + | { success: true; oldUri: string; newUri: string; skipped?: boolean } 11 11 + | { success: false; error: string }; 12 12 + 13 13 + async function createAuthenticatedAgent(did: string): Promise<AtpBaseClient> { 14 14 + const result = await restoreOAuthSession(did); 15 15 + if (!result.ok) { 16 16 + throw new Error(`Failed to restore OAuth session: ${result.error.message}`); 17 17 + } 18 18 + const credentialSession = result.value; 19 19 + return new AtpBaseClient( 20 20 + credentialSession.fetchHandler.bind(credentialSession) 21 21 + ); 22 22 + } 23 23 + 24 24 + export const migrate_user_to_standard = inngest.createFunction( 25 25 + { id: "migrate_user_to_standard" }, 26 26 + { event: "user/migrate-to-standard" }, 27 27 + async ({ event, step }) => { 28 28 + const { did } = event.data; 29 29 + 30 30 + const stats = { 31 31 + publicationsMigrated: 0, 32 32 + documentsMigrated: 0, 33 33 + userSubscriptionsMigrated: 0, 34 34 + referencesUpdated: 0, 35 35 + errors: [] as string[], 36 36 + }; 37 37 + 38 38 + // Step 1: Verify OAuth session is valid 39 39 + await step.run("verify-oauth-session", async () => { 40 40 + const result = await restoreOAuthSession(did); 41 41 + if (!result.ok) { 42 42 + throw new Error(`Failed to restore OAuth session: ${result.error.message}`); 43 43 + } 44 44 + return { success: true }; 45 45 + }); 46 46 + 47 47 + // Step 2: Get user's pub.leaflet.publication records 48 48 + const oldPublications = await step.run("fetch-old-publications", async () => { 49 49 + const { data, error } = await supabaseServerClient 50 50 + .from("publications") 51 51 + .select("*") 52 52 + .eq("identity_did", did) 53 53 + .like("uri", `at://${did}/pub.leaflet.publication/%`); 54 54 + 55 55 + if (error) throw new Error(`Failed to fetch publications: ${error.message}`); 56 56 + return data || []; 57 57 + }); 58 58 + 59 59 + // Step 3: Migrate each publication 60 60 + const publicationUriMap: Record<string, string> = {}; // old URI -> new URI 61 61 + 62 62 + for (const pub of oldPublications) { 63 63 + const aturi = new AtUri(pub.uri); 64 64 + 65 65 + // Skip if already a site.standard.publication 66 66 + if (aturi.collection === "site.standard.publication") { 67 67 + publicationUriMap[pub.uri] = pub.uri; 68 68 + continue; 69 69 + } 70 70 + 71 71 + const rkey = aturi.rkey; 72 72 + const normalized = normalizePublicationRecord(pub.record); 73 73 + 74 74 + if (!normalized) { 75 75 + stats.errors.push(`Publication ${pub.uri}: Failed to normalize publication record`); 76 76 + continue; 77 77 + } 78 78 + 79 79 + // Build site.standard.publication record 80 80 + const newRecord: SiteStandardPublication.Record = { 81 81 + $type: "site.standard.publication", 82 82 + name: normalized.name, 83 83 + url: normalized.url, 84 84 + description: normalized.description, 85 85 + icon: normalized.icon, 86 86 + theme: normalized.theme, 87 87 + basicTheme: normalized.basicTheme, 88 88 + preferences: normalized.preferences, 89 89 + }; 90 90 + 91 91 + // Step: Write to PDS 92 92 + const pdsResult = await step.run(`pds-write-publication-${pub.uri}`, async () => { 93 93 + const agent = await createAuthenticatedAgent(did); 94 94 + const putResult = await agent.com.atproto.repo.putRecord({ 95 95 + repo: did, 96 96 + collection: "site.standard.publication", 97 97 + rkey, 98 98 + record: newRecord, 99 99 + validate: false, 100 100 + }); 101 101 + return { newUri: putResult.data.uri }; 102 102 + }); 103 103 + 104 104 + const newUri = pdsResult.newUri; 105 105 + 106 106 + // Step: Write to database 107 107 + const dbResult = await step.run(`db-write-publication-${pub.uri}`, async () => { 108 108 + const { error: dbError } = await supabaseServerClient 109 109 + .from("publications") 110 110 + .upsert({ 111 111 + uri: newUri, 112 112 + identity_did: did, 113 113 + name: normalized.name, 114 114 + record: newRecord as Json, 115 115 + }); 116 116 + 117 117 + if (dbError) { 118 118 + return { success: false as const, error: dbError.message }; 119 119 + } 120 120 + return { success: true as const }; 121 121 + }); 122 122 + 123 123 + if (dbResult.success) { 124 124 + publicationUriMap[pub.uri] = newUri; 125 125 + stats.publicationsMigrated++; 126 126 + } else { 127 127 + stats.errors.push(`Publication ${pub.uri}: Database error: ${dbResult.error}`); 128 128 + } 129 129 + } 130 130 + 131 131 + // Step 4: Get and migrate documents for these publications 132 132 + const oldDocuments = await step.run("fetch-old-documents", async () => { 133 133 + const oldPubUris = Object.keys(publicationUriMap); 134 134 + if (oldPubUris.length === 0) return []; 135 135 + 136 136 + const { data, error } = await supabaseServerClient 137 137 + .from("documents_in_publications") 138 138 + .select("document, publication, documents(uri, data)") 139 139 + .in("publication", oldPubUris); 140 140 + 141 141 + if (error) throw new Error(`Failed to fetch documents: ${error.message}`); 142 142 + return data || []; 143 143 + }); 144 144 + 145 145 + const documentUriMap: Record<string, string> = {}; // old URI -> new URI 146 146 + 147 147 + for (const docRow of oldDocuments) { 148 148 + if (!docRow.documents) continue; 149 149 + const doc = docRow.documents as { uri: string; data: Json }; 150 150 + const aturi = new AtUri(doc.uri); 151 151 + 152 152 + // Skip if already a site.standard.document 153 153 + if (aturi.collection === "site.standard.document") { 154 154 + documentUriMap[doc.uri] = doc.uri; 155 155 + continue; 156 156 + } 157 157 + 158 158 + const rkey = aturi.rkey; 159 159 + const normalized = normalizeDocumentRecord(doc.data); 160 160 + 161 161 + if (!normalized) { 162 162 + stats.errors.push(`Document ${doc.uri}: Failed to normalize document record`); 163 163 + continue; 164 164 + } 165 165 + 166 166 + // Get the new publication URI 167 167 + const newPubUri = publicationUriMap[docRow.publication]; 168 168 + if (!newPubUri) { 169 169 + stats.errors.push(`Document ${doc.uri}: No migrated publication found`); 170 170 + continue; 171 171 + } 172 172 + 173 173 + // Build site.standard.document record 174 174 + const newRecord: SiteStandardDocument.Record = { 175 175 + $type: "site.standard.document", 176 176 + title: normalized.title || "Untitled", 177 177 + site: newPubUri, 178 178 + publishedAt: normalized.publishedAt || new Date().toISOString(), 179 179 + description: normalized.description, 180 180 + content: normalized.content, 181 181 + path: normalized.path, 182 182 + tags: normalized.tags, 183 183 + coverImage: normalized.coverImage, 184 184 + bskyPostRef: normalized.bskyPostRef, 185 185 + }; 186 186 + 187 187 + // Step: Write to PDS 188 188 + const pdsResult = await step.run(`pds-write-document-${doc.uri}`, async () => { 189 189 + const agent = await createAuthenticatedAgent(did); 190 190 + const putResult = await agent.com.atproto.repo.putRecord({ 191 191 + repo: did, 192 192 + collection: "site.standard.document", 193 193 + rkey, 194 194 + record: newRecord, 195 195 + validate: false, 196 196 + }); 197 197 + return { newUri: putResult.data.uri }; 198 198 + }); 199 199 + 200 200 + const newUri = pdsResult.newUri; 201 201 + 202 202 + // Step: Write to database 203 203 + const dbResult = await step.run(`db-write-document-${doc.uri}`, async () => { 204 204 + const { error: dbError } = await supabaseServerClient 205 205 + .from("documents") 206 206 + .upsert({ 207 207 + uri: newUri, 208 208 + data: newRecord as Json, 209 209 + }); 210 210 + 211 211 + if (dbError) { 212 212 + return { success: false as const, error: dbError.message }; 213 213 + } 214 214 + 215 215 + // Add to documents_in_publications with new URIs 216 216 + await supabaseServerClient 217 217 + .from("documents_in_publications") 218 218 + .upsert({ 219 219 + publication: newPubUri, 220 220 + document: newUri, 221 221 + }); 222 222 + 223 223 + return { success: true as const }; 224 224 + }); 225 225 + 226 226 + if (dbResult.success) { 227 227 + documentUriMap[doc.uri] = newUri; 228 228 + stats.documentsMigrated++; 229 229 + } else { 230 230 + stats.errors.push(`Document ${doc.uri}: Database error: ${dbResult.error}`); 231 231 + } 232 232 + } 233 233 + 234 234 + // Step 5: Update references in database tables 235 235 + await step.run("update-references", async () => { 236 236 + // Update leaflets_in_publications - update publication and doc references 237 237 + for (const [oldUri, newUri] of Object.entries(publicationUriMap)) { 238 238 + const { error } = await supabaseServerClient 239 239 + .from("leaflets_in_publications") 240 240 + .update({ publication: newUri }) 241 241 + .eq("publication", oldUri); 242 242 + 243 243 + if (!error) stats.referencesUpdated++; 244 244 + } 245 245 + 246 246 + for (const [oldUri, newUri] of Object.entries(documentUriMap)) { 247 247 + const { error } = await supabaseServerClient 248 248 + .from("leaflets_in_publications") 249 249 + .update({ doc: newUri }) 250 250 + .eq("doc", oldUri); 251 251 + 252 252 + if (!error) stats.referencesUpdated++; 253 253 + } 254 254 + 255 255 + // Update leaflets_to_documents - update document references 256 256 + for (const [oldUri, newUri] of Object.entries(documentUriMap)) { 257 257 + const { error } = await supabaseServerClient 258 258 + .from("leaflets_to_documents") 259 259 + .update({ document: newUri }) 260 260 + .eq("document", oldUri); 261 261 + 262 262 + if (!error) stats.referencesUpdated++; 263 263 + } 264 264 + 265 265 + // Update publication_domains - update publication references 266 266 + for (const [oldUri, newUri] of Object.entries(publicationUriMap)) { 267 267 + const { error } = await supabaseServerClient 268 268 + .from("publication_domains") 269 269 + .update({ publication: newUri }) 270 270 + .eq("publication", oldUri); 271 271 + 272 272 + if (!error) stats.referencesUpdated++; 273 273 + } 274 274 + 275 275 + // Update comments_on_documents - update document references 276 276 + for (const [oldUri, newUri] of Object.entries(documentUriMap)) { 277 277 + const { error } = await supabaseServerClient 278 278 + .from("comments_on_documents") 279 279 + .update({ document: newUri }) 280 280 + .eq("document", oldUri); 281 281 + 282 282 + if (!error) stats.referencesUpdated++; 283 283 + } 284 284 + 285 285 + // Update document_mentions_in_bsky - update document references 286 286 + for (const [oldUri, newUri] of Object.entries(documentUriMap)) { 287 287 + const { error } = await supabaseServerClient 288 288 + .from("document_mentions_in_bsky") 289 289 + .update({ document: newUri }) 290 290 + .eq("document", oldUri); 291 291 + 292 292 + if (!error) stats.referencesUpdated++; 293 293 + } 294 294 + 295 295 + // Update subscribers_to_publications - update publication references 296 296 + for (const [oldUri, newUri] of Object.entries(publicationUriMap)) { 297 297 + const { error } = await supabaseServerClient 298 298 + .from("subscribers_to_publications") 299 299 + .update({ publication: newUri }) 300 300 + .eq("publication", oldUri); 301 301 + 302 302 + if (!error) stats.referencesUpdated++; 303 303 + } 304 304 + 305 305 + // Update publication_subscriptions - update publication references for incoming subscriptions 306 306 + for (const [oldUri, newUri] of Object.entries(publicationUriMap)) { 307 307 + const { error } = await supabaseServerClient 308 308 + .from("publication_subscriptions") 309 309 + .update({ publication: newUri }) 310 310 + .eq("publication", oldUri); 311 311 + 312 312 + if (!error) stats.referencesUpdated++; 313 313 + } 314 314 + 315 315 + return stats.referencesUpdated; 316 316 + }); 317 317 + 318 318 + // Step 6: Migrate user's own subscriptions - subscriptions BY this user to other publications 319 319 + const userSubscriptions = await step.run("fetch-user-subscriptions", async () => { 320 320 + const { data, error } = await supabaseServerClient 321 321 + .from("publication_subscriptions") 322 322 + .select("*") 323 323 + .eq("identity", did) 324 324 + .like("uri", `at://${did}/pub.leaflet.graph.subscription/%`); 325 325 + 326 326 + if (error) throw new Error(`Failed to fetch user subscriptions: ${error.message}`); 327 327 + return data || []; 328 328 + }); 329 329 + 330 330 + const userSubscriptionUriMap: Record<string, string> = {}; // old URI -> new URI 331 331 + 332 332 + for (const sub of userSubscriptions) { 333 333 + const aturi = new AtUri(sub.uri); 334 334 + 335 335 + // Skip if already a site.standard.graph.subscription 336 336 + if (aturi.collection === "site.standard.graph.subscription") { 337 337 + userSubscriptionUriMap[sub.uri] = sub.uri; 338 338 + continue; 339 339 + } 340 340 + 341 341 + const rkey = aturi.rkey; 342 342 + 343 343 + // Build site.standard.graph.subscription record 344 344 + const newRecord: SiteStandardGraphSubscription.Record = { 345 345 + $type: "site.standard.graph.subscription", 346 346 + publication: sub.publication, 347 347 + }; 348 348 + 349 349 + // Step: Write to PDS 350 350 + const pdsResult = await step.run(`pds-write-subscription-${sub.uri}`, async () => { 351 351 + const agent = await createAuthenticatedAgent(did); 352 352 + const putResult = await agent.com.atproto.repo.putRecord({ 353 353 + repo: did, 354 354 + collection: "site.standard.graph.subscription", 355 355 + rkey, 356 356 + record: newRecord, 357 357 + validate: false, 358 358 + }); 359 359 + return { newUri: putResult.data.uri }; 360 360 + }); 361 361 + 362 362 + const newUri = pdsResult.newUri; 363 363 + 364 364 + // Step: Write to database 365 365 + const dbResult = await step.run(`db-write-subscription-${sub.uri}`, async () => { 366 366 + const { error: dbError } = await supabaseServerClient 367 367 + .from("publication_subscriptions") 368 368 + .update({ 369 369 + uri: newUri, 370 370 + record: newRecord as Json, 371 371 + }) 372 372 + .eq("uri", sub.uri); 373 373 + 374 374 + if (dbError) { 375 375 + return { success: false as const, error: dbError.message }; 376 376 + } 377 377 + return { success: true as const }; 378 378 + }); 379 379 + 380 380 + if (dbResult.success) { 381 381 + userSubscriptionUriMap[sub.uri] = newUri; 382 382 + stats.userSubscriptionsMigrated++; 383 383 + } else { 384 384 + stats.errors.push(`User subscription ${sub.uri}: Database error: ${dbResult.error}`); 385 385 + } 386 386 + } 387 387 + 388 388 + // Step 7: Delete old records from our database tables 389 389 + await step.run("delete-old-db-records", async () => { 390 390 + const oldPubUris = Object.keys(publicationUriMap).filter(uri => 391 391 + new AtUri(uri).collection === "pub.leaflet.publication" 392 392 + ); 393 393 + const oldDocUris = Object.keys(documentUriMap).filter(uri => 394 394 + new AtUri(uri).collection === "pub.leaflet.document" 395 395 + ); 396 396 + 397 397 + // NOTE: We intentionally keep old documents_in_publications entries. 398 398 + // New entries are created in Step 4 with the new URIs, but the old entries 399 399 + // should remain so that notifications and other references that point to 400 400 + // old document/publication URIs can still look up the relationship. 401 401 + 402 402 + // Delete from documents (old document URIs) 403 403 + if (oldDocUris.length > 0) { 404 404 + await supabaseServerClient 405 405 + .from("documents") 406 406 + .delete() 407 407 + .in("uri", oldDocUris); 408 408 + } 409 409 + 410 410 + // Delete from publications (old publication URIs) 411 411 + if (oldPubUris.length > 0) { 412 412 + await supabaseServerClient 413 413 + .from("publications") 414 414 + .delete() 415 415 + .in("uri", oldPubUris); 416 416 + } 417 417 + }); 418 418 + 419 419 + return { 420 420 + success: stats.errors.length === 0, 421 421 + stats, 422 422 + publicationUriMap, 423 423 + documentUriMap, 424 424 + userSubscriptionUriMap, 425 425 + }; 426 426 + } 427 427 + );

+2

app/api/inngest/route.tsx

··· 4 4 import { come_online } from "./functions/come_online"; 5 5 import { batched_update_profiles } from "./functions/batched_update_profiles"; 6 6 import { index_follows } from "./functions/index_follows"; 7 7 + import { migrate_user_to_standard } from "./functions/migrate_user_to_standard"; 7 8 8 9 export const { GET, POST, PUT } = serve({ 9 10 client: inngest, ··· 12 13 come_online, 13 14 batched_update_profiles, 14 15 index_follows, 16 16 + migrate_user_to_standard, 15 17 ], 16 18 });

+11 -4

app/api/rpc/[command]/get_publication_data.ts

··· 4 4 import { AtUri } from "@atproto/syntax"; 5 5 import { getFactsFromHomeLeaflets } from "./getFactsFromHomeLeaflets"; 6 6 import { normalizeDocumentRecord } from "src/utils/normalizeRecords"; 7 7 + import { ids } from "lexicons/api/lexicons"; 7 8 8 9 export type GetPublicationDataReturnType = Awaited< 9 10 ReturnType<(typeof get_publication_data)["handler"]> ··· 18 19 { did, publication_name }, 19 20 { supabase }: Pick<Env, "supabase">, 20 21 ) => { 21 21 - let uri; 22 22 + let pubLeafletUri; 23 23 + let siteStandardUri; 22 24 if (/^(?!\.$|\.\.S)[A-Za-z0-9._:~-]{1,512}$/.test(publication_name)) { 23 23 - uri = AtUri.make( 25 25 + pubLeafletUri = AtUri.make( 26 26 + did, 27 27 + ids.PubLeafletPublication, 28 28 + publication_name, 29 29 + ).toString(); 30 30 + siteStandardUri = AtUri.make( 24 31 did, 25 25 - "pub.leaflet.publication", 32 32 + ids.SiteStandardPublication, 26 33 publication_name, 27 34 ).toString(); 28 35 } ··· 45 52 ) 46 53 )`, 47 54 ) 48 48 - .or(`name.eq."${publication_name}", uri.eq."${uri}"`) 55 55 + .or(`name.eq."${publication_name}", uri.eq."${pubLeafletUri}", uri.eq."${siteStandardUri}"`) 49 56 .eq("identity_did", did) 50 57 .single(); 51 58

+159 -79

app/lish/createPub/updatePublication.ts

··· 4 4 AtpBaseClient, 5 5 PubLeafletPublication, 6 6 PubLeafletThemeColor, 7 7 + SiteStandardPublication, 7 8 } from "lexicons/api"; 8 9 import { restoreOAuthSession, OAuthSessionError } from "src/atproto-oauth"; 9 10 import { getIdentityData } from "actions/getIdentityData"; ··· 66 67 // Preserve existing schema when updating 67 68 const publicationType = getPublicationType(aturi.collection); 68 69 69 69 - let record = { 70 70 - $type: publicationType, 71 71 - ...(existingPub.record as object), 72 72 - name, 73 73 - } as PubLeafletPublication.Record; 74 74 - if (preferences) { 75 75 - record.preferences = preferences; 76 76 - } 77 77 - 78 78 - if (description !== undefined) { 79 79 - record.description = description; 80 80 - } 70 70 + // Normalize the existing record to read its properties 71 71 + const normalizedPub = normalizePublicationRecord(existingPub.record); 72 72 + // Extract base_path from url if it exists (url format is https://domain, base_path is just domain) 73 73 + const existingBasePath = normalizedPub?.url 74 74 + ? normalizedPub.url.replace(/^https?:\/\//, "") 75 75 + : undefined; 81 76 82 82 - // Upload the icon if provided How do I tell if there isn't a new one? 77 77 + // Upload the icon if provided 78 78 + let iconBlob = normalizedPub?.icon; 83 79 if (iconFile && iconFile.size > 0) { 84 80 const buffer = await iconFile.arrayBuffer(); 85 81 const uploadResult = await agent.com.atproto.repo.uploadBlob( ··· 88 84 ); 89 85 90 86 if (uploadResult.data.blob) { 91 91 - record.icon = uploadResult.data.blob; 87 87 + iconBlob = uploadResult.data.blob; 92 88 } 93 89 } 94 90 91 91 + // Build preferences based on input or existing normalized preferences 92 92 + const preferencesData = preferences || normalizedPub?.preferences; 93 93 + 94 94 + // Build the record with the correct field based on publication type 95 95 + const record = 96 96 + publicationType === "site.standard.publication" 97 97 + ? ({ 98 98 + $type: publicationType, 99 99 + name, 100 100 + description: description !== undefined ? description : normalizedPub?.description, 101 101 + icon: iconBlob, 102 102 + theme: normalizedPub?.theme, 103 103 + preferences: preferencesData 104 104 + ? { 105 105 + $type: "site.standard.publication#preferences" as const, 106 106 + showInDiscover: preferencesData.showInDiscover, 107 107 + showComments: preferencesData.showComments, 108 108 + showMentions: preferencesData.showMentions, 109 109 + showPrevNext: preferencesData.showPrevNext, 110 110 + } 111 111 + : undefined, 112 112 + url: normalizedPub?.url || "", 113 113 + } as SiteStandardPublication.Record) 114 114 + : ({ 115 115 + $type: publicationType, 116 116 + name, 117 117 + description: description !== undefined ? description : normalizedPub?.description, 118 118 + icon: iconBlob, 119 119 + theme: normalizedPub?.theme, 120 120 + preferences: preferencesData 121 121 + ? { 122 122 + $type: "pub.leaflet.publication#preferences" as const, 123 123 + showInDiscover: preferencesData.showInDiscover, 124 124 + showComments: preferencesData.showComments, 125 125 + showMentions: preferencesData.showMentions, 126 126 + showPrevNext: preferencesData.showPrevNext, 127 127 + } 128 128 + : undefined, 129 129 + base_path: existingBasePath, 130 130 + } as PubLeafletPublication.Record); 131 131 + 95 132 let result = await agent.com.atproto.repo.putRecord({ 96 133 repo: credentialSession.did!, 97 134 rkey: aturi.rkey, ··· 159 196 ? normalizedPub.url.replace(/^https?:\/\//, "") 160 197 : undefined; 161 198 162 162 - let record = { 163 163 - $type: publicationType, 164 164 - name: normalizedPub?.name || "", 165 165 - description: normalizedPub?.description, 166 166 - icon: normalizedPub?.icon, 167 167 - theme: normalizedPub?.theme, 168 168 - preferences: normalizedPub?.preferences 169 169 - ? { 170 170 - $type: "pub.leaflet.publication#preferences" as const, 171 171 - showInDiscover: normalizedPub.preferences.showInDiscover, 172 172 - showComments: normalizedPub.preferences.showComments, 173 173 - showMentions: normalizedPub.preferences.showMentions, 174 174 - showPrevNext: normalizedPub.preferences.showPrevNext, 175 175 - } 176 176 - : undefined, 177 177 - base_path, 178 178 - } as PubLeafletPublication.Record; 199 199 + // Build the record with the correct field based on publication type 200 200 + const record = 201 201 + publicationType === "site.standard.publication" 202 202 + ? ({ 203 203 + $type: publicationType, 204 204 + name: normalizedPub?.name || "", 205 205 + description: normalizedPub?.description, 206 206 + icon: normalizedPub?.icon, 207 207 + theme: normalizedPub?.theme, 208 208 + preferences: normalizedPub?.preferences 209 209 + ? { 210 210 + $type: "site.standard.publication#preferences" as const, 211 211 + showInDiscover: normalizedPub.preferences.showInDiscover, 212 212 + showComments: normalizedPub.preferences.showComments, 213 213 + showMentions: normalizedPub.preferences.showMentions, 214 214 + showPrevNext: normalizedPub.preferences.showPrevNext, 215 215 + } 216 216 + : undefined, 217 217 + url: `https://${base_path}`, 218 218 + } as SiteStandardPublication.Record) 219 219 + : ({ 220 220 + $type: publicationType, 221 221 + name: normalizedPub?.name || "", 222 222 + description: normalizedPub?.description, 223 223 + icon: normalizedPub?.icon, 224 224 + theme: normalizedPub?.theme, 225 225 + preferences: normalizedPub?.preferences 226 226 + ? { 227 227 + $type: "pub.leaflet.publication#preferences" as const, 228 228 + showInDiscover: normalizedPub.preferences.showInDiscover, 229 229 + showComments: normalizedPub.preferences.showComments, 230 230 + showMentions: normalizedPub.preferences.showMentions, 231 231 + showPrevNext: normalizedPub.preferences.showPrevNext, 232 232 + } 233 233 + : undefined, 234 234 + base_path, 235 235 + } as PubLeafletPublication.Record); 179 236 180 237 let result = await agent.com.atproto.repo.putRecord({ 181 238 repo: credentialSession.did!, ··· 257 314 ? normalizedPub.url.replace(/^https?:\/\//, "") 258 315 : undefined; 259 316 260 260 - let record = { 261 261 - $type: publicationType, 262 262 - name: normalizedPub?.name || "", 263 263 - description: normalizedPub?.description, 264 264 - icon: normalizedPub?.icon, 265 265 - base_path: existingBasePath, 266 266 - preferences: normalizedPub?.preferences 317 317 + // Build theme object (shared between both publication types) 318 318 + const themeData = { 319 319 + backgroundImage: theme.backgroundImage 267 320 ? { 268 268 - $type: "pub.leaflet.publication#preferences" as const, 269 269 - showInDiscover: normalizedPub.preferences.showInDiscover, 270 270 - showComments: normalizedPub.preferences.showComments, 271 271 - showMentions: normalizedPub.preferences.showMentions, 272 272 - showPrevNext: normalizedPub.preferences.showPrevNext, 321 321 + $type: "pub.leaflet.theme.backgroundImage", 322 322 + image: ( 323 323 + await agent.com.atproto.repo.uploadBlob( 324 324 + new Uint8Array(await theme.backgroundImage.arrayBuffer()), 325 325 + { encoding: theme.backgroundImage.type }, 326 326 + ) 327 327 + )?.data.blob, 328 328 + width: theme.backgroundRepeat || undefined, 329 329 + repeat: !!theme.backgroundRepeat, 330 330 + } 331 331 + : theme.backgroundImage === null 332 332 + ? undefined 333 333 + : normalizedPub?.theme?.backgroundImage, 334 334 + backgroundColor: theme.backgroundColor 335 335 + ? { 336 336 + ...theme.backgroundColor, 273 337 } 274 338 : undefined, 275 275 - theme: { 276 276 - backgroundImage: theme.backgroundImage 277 277 - ? { 278 278 - $type: "pub.leaflet.theme.backgroundImage", 279 279 - image: ( 280 280 - await agent.com.atproto.repo.uploadBlob( 281 281 - new Uint8Array(await theme.backgroundImage.arrayBuffer()), 282 282 - { encoding: theme.backgroundImage.type }, 283 283 - ) 284 284 - )?.data.blob, 285 285 - width: theme.backgroundRepeat || undefined, 286 286 - repeat: !!theme.backgroundRepeat, 287 287 - } 288 288 - : theme.backgroundImage === null 289 289 - ? undefined 290 290 - : normalizedPub?.theme?.backgroundImage, 291 291 - backgroundColor: theme.backgroundColor 292 292 - ? { 293 293 - ...theme.backgroundColor, 294 294 - } 295 295 - : undefined, 296 296 - pageWidth: theme.pageWidth, 297 297 - primary: { 298 298 - ...theme.primary, 299 299 - }, 300 300 - pageBackground: { 301 301 - ...theme.pageBackground, 302 302 - }, 303 303 - showPageBackground: theme.showPageBackground, 304 304 - accentBackground: { 305 305 - ...theme.accentBackground, 306 306 - }, 307 307 - accentText: { 308 308 - ...theme.accentText, 309 309 - }, 339 339 + pageWidth: theme.pageWidth, 340 340 + primary: { 341 341 + ...theme.primary, 342 342 + }, 343 343 + pageBackground: { 344 344 + ...theme.pageBackground, 345 345 + }, 346 346 + showPageBackground: theme.showPageBackground, 347 347 + accentBackground: { 348 348 + ...theme.accentBackground, 349 349 + }, 350 350 + accentText: { 351 351 + ...theme.accentText, 310 352 }, 311 311 - } as PubLeafletPublication.Record; 353 353 + }; 354 354 + 355 355 + // Build the record with the correct field based on publication type 356 356 + const record = 357 357 + publicationType === "site.standard.publication" 358 358 + ? ({ 359 359 + $type: publicationType, 360 360 + name: normalizedPub?.name || "", 361 361 + description: normalizedPub?.description, 362 362 + icon: normalizedPub?.icon, 363 363 + url: normalizedPub?.url || "", 364 364 + preferences: normalizedPub?.preferences 365 365 + ? { 366 366 + $type: "site.standard.publication#preferences" as const, 367 367 + showInDiscover: normalizedPub.preferences.showInDiscover, 368 368 + showComments: normalizedPub.preferences.showComments, 369 369 + showMentions: normalizedPub.preferences.showMentions, 370 370 + showPrevNext: normalizedPub.preferences.showPrevNext, 371 371 + } 372 372 + : undefined, 373 373 + theme: themeData, 374 374 + } as SiteStandardPublication.Record) 375 375 + : ({ 376 376 + $type: publicationType, 377 377 + name: normalizedPub?.name || "", 378 378 + description: normalizedPub?.description, 379 379 + icon: normalizedPub?.icon, 380 380 + base_path: existingBasePath, 381 381 + preferences: normalizedPub?.preferences 382 382 + ? { 383 383 + $type: "pub.leaflet.publication#preferences" as const, 384 384 + showInDiscover: normalizedPub.preferences.showInDiscover, 385 385 + showComments: normalizedPub.preferences.showComments, 386 386 + showMentions: normalizedPub.preferences.showMentions, 387 387 + showPrevNext: normalizedPub.preferences.showPrevNext, 388 388 + } 389 389 + : undefined, 390 390 + theme: themeData, 391 391 + } as PubLeafletPublication.Record); 312 392 313 393 let result = await agent.com.atproto.repo.putRecord({ 314 394 repo: credentialSession.did!,

+9 -5

app/lish/subscribeToPublication.ts

··· 48 48 let agent = new AtpBaseClient( 49 49 credentialSession.fetchHandler.bind(credentialSession), 50 50 ); 51 51 - let record = await agent.pub.leaflet.graph.subscription.create( 51 51 + let record = await agent.site.standard.graph.subscription.create( 52 52 { repo: credentialSession.did!, rkey: TID.nextStr() }, 53 53 { 54 54 publication, ··· 140 140 .eq("publication", publication) 141 141 .single(); 142 142 if (!existingSubscription) return { success: true }; 143 143 - await agent.pub.leaflet.graph.subscription.delete({ 144 144 - repo: credentialSession.did!, 145 145 - rkey: new AtUri(existingSubscription.uri).rkey, 146 146 - }); 143 143 + 144 144 + // Delete from both collections (old and new schema) - one or both may exist 145 145 + let rkey = new AtUri(existingSubscription.uri).rkey; 146 146 + await Promise.all([ 147 147 + agent.pub.leaflet.graph.subscription.delete({ repo: credentialSession.did!, rkey }).catch(() => {}), 148 148 + agent.site.standard.graph.subscription.delete({ repo: credentialSession.did!, rkey }).catch(() => {}), 149 149 + ]); 150 150 + 147 151 await supabaseServerClient 148 152 .from("publication_subscriptions") 149 153 .delete()

+4 -1

appview/index.ts

··· 247 247 if (docResult.error) console.log(docResult.error); 248 248 249 249 // site.standard.document uses "site" field to reference the publication 250 250 - if (record.value.site) { 250 250 + // For documents in publications, site is an AT-URI (at://did:plc:xxx/site.standard.publication/rkey) 251 251 + // For standalone documents, site is an HTTPS URL (https://leaflet.pub/p/did:plc:xxx) 252 252 + // Only link to publications table for AT-URI sites 253 253 + if (record.value.site && record.value.site.startsWith("at://")) { 251 254 let siteURI = new AtUri(record.value.site); 252 255 253 256 if (siteURI.host !== evt.uri.host) {