rename to plonk.li

lexicons/comment.json

···
 {
   "lexicon": 1,
-  "id": "ovh.plonk.comment",
+  "id": "li.plonk.comment",
   "defs": {
     "main": {
       "type": "record",

lexicons/paste.json

···
 {
   "lexicon": 1,
-  "id": "ovh.plonk.paste",
+  "id": "li.plonk.paste",
   "defs": {
     "main": {
       "type": "record",

src/ingester.ts

···
 import { IdResolver } from "@atproto/identity";
 import { Firehose } from "@atproto/sync";
 import type { Database } from "#/db";
-import * as Paste from "#/lexicons/types/ovh/plonk/paste";
-import * as Comment from "#/lexicons/types/ovh/plonk/comment";
+import * as Paste from "#/lexicons/types/li/plonk/paste";
+import * as Comment from "#/lexicons/types/li/plonk/comment";
 
 export function createIngester(db: Database, idResolver: IdResolver) {
 	const logger = pino({ name: "firehose ingestion" });
···
 
 				// If the write is a valid status update
 				if (
-					evt.collection === "ovh.plonk.paste" &&
+					evt.collection === "li.plonk.paste" &&
 					Paste.isRecord(record) &&
 					Paste.validateRecord(record).success
 				) {
···
 						)
 						.execute();
 				} else if (
-					evt.collection === "ovh.plonk.comment" &&
+					evt.collection === "li.plonk.comment" &&
 					Comment.isRecord(record) &&
 					Comment.validateRecord(record).success
 				) {
···
 				}
 			} else if (
 				evt.event === "delete" &&
-				evt.collection === "ovh.plonk.paste"
+				evt.collection === "li.plonk.paste"
 			) {
 				// Remove the status from our SQLite
 				await db
···
 					.execute();
 			} else if (
 				evt.event === "delete" &&
-				evt.collection === "ovh.plonk.comment"
+				evt.collection === "li.plonk.comment"
 			) {
 				// Remove the status from our SQLite
 				await db
···
 		onError: (err) => {
 			logger.error({ err }, "error on firehose ingestion");
 		},
-		filterCollections: ["ovh.plonk.paste"],
+		filterCollections: ["li.plonk.paste"],
 		excludeIdentity: true,
 		excludeAccount: true,
 	});

src/lexicons/index.ts

···
 
 export class Server {
   xrpc: XrpcServer
-  ovh: OvhNS
+  li: LiNS
   com: ComNS
   app: AppNS
 
   constructor(options?: XrpcOptions) {
     this.xrpc = createXrpcServer(schemas, options)
-    this.ovh = new OvhNS(this)
+    this.li = new LiNS(this)
     this.com = new ComNS(this)
     this.app = new AppNS(this)
   }
 }
 
-export class OvhNS {
+export class LiNS {
   _server: Server
-  plonk: OvhPlonkNS
+  plonk: LiPlonkNS
 
   constructor(server: Server) {
     this._server = server
-    this.plonk = new OvhPlonkNS(server)
+    this.plonk = new LiPlonkNS(server)
   }
 }
 
-export class OvhPlonkNS {
+export class LiPlonkNS {
   _server: Server
 
   constructor(server: Server) {

src/lexicons/lexicons.ts

···
 import { LexiconDoc, Lexicons } from '@atproto/lexicon'
 
 export const schemaDict = {
-  OvhPlonkComment: {
+  LiPlonkComment: {
     lexicon: 1,
-    id: 'ovh.plonk.comment',
+    id: 'li.plonk.comment',
     defs: {
       main: {
         type: 'record',
···
       },
     },
   },
-  OvhPlonkPaste: {
+  LiPlonkPaste: {
     lexicon: 1,
-    id: 'ovh.plonk.paste',
+    id: 'li.plonk.paste',
     defs: {
       main: {
         type: 'record',
···
 export const schemas: LexiconDoc[] = Object.values(schemaDict) as LexiconDoc[]
 export const lexicons: Lexicons = new Lexicons(schemas)
 export const ids = {
-  OvhPlonkComment: 'ovh.plonk.comment',
+  LiPlonkComment: 'li.plonk.comment',
   ComAtprotoLabelDefs: 'com.atproto.label.defs',
   ComAtprotoRepoGetRecord: 'com.atproto.repo.getRecord',
   ComAtprotoRepoListRecords: 'com.atproto.repo.listRecords',
-  OvhPlonkPaste: 'ovh.plonk.paste',
+  LiPlonkPaste: 'li.plonk.paste',
   AppBskyActorProfile: 'app.bsky.actor.profile',
   ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
 }

src/lexicons/types/ovh/plonk/comment.ts src/lexicons/types/li/plonk/comment.ts

···
   return (
     isObj(v) &&
     hasProp(v, '$type') &&
-    (v.$type === 'ovh.plonk.comment#main' || v.$type === 'ovh.plonk.comment')
+    (v.$type === 'li.plonk.comment#main' || v.$type === 'li.plonk.comment')
   )
 }
 
 export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('ovh.plonk.comment#main', v)
+  return lexicons.validate('li.plonk.comment#main', v)
 }

src/lexicons/types/ovh/plonk/paste.ts src/lexicons/types/li/plonk/paste.ts

···
   return (
     isObj(v) &&
     hasProp(v, '$type') &&
-    (v.$type === 'ovh.plonk.paste#main' || v.$type === 'ovh.plonk.paste')
+    (v.$type === 'li.plonk.paste#main' || v.$type === 'li.plonk.paste')
   )
 }
 
 export function validateRecord(v: unknown): ValidationResult {
-  return lexicons.validate('ovh.plonk.paste#main', v)
+  return lexicons.validate('li.plonk.paste#main', v)
 }

src/public/styles.css

···
   justify-content: space-between;
   align-items: center;
 }
+
+select {
+  -webkit-appearance: none;
+  -moz-appearance: none;
+  text-indent: 1px;
+  text-overflow: '';
+}

src/routes.ts

···
 import { Agent } from "@atproto/api";
 import { newShortUrl } from "#/db";
 
-import * as Paste from "#/lexicons/types/ovh/plonk/paste";
-import * as Comment from "#/lexicons/types/ovh/plonk/comment";
+import * as Paste from "#/lexicons/types/li/plonk/paste";
+import * as Comment from "#/lexicons/types/li/plonk/comment";
 import { ComAtprotoRepoNS } from "#/lexicons";
 
 type Session = {
···
 		const agent = new Agent(pds);
 		const response = await agent.com.atproto.repo.listRecords({
 			repo: authorDid,
-			collection: 'ovh.plonk.paste',
+			collection: 'li.plonk.paste',
 			limit: 99,
 		});
 		const pastes = response.data.records;
···
 		}
 		const response = await agent.com.atproto.repo.listRecords({
 			repo: agent.assertDid,
-			collection: 'ovh.plonk.paste',
+			collection: 'li.plonk.paste',
 			limit: 10,
 		});
 		const vals = response.data.records;
···
 		const rkey = TID.nextStr();
 		const shortUrl = await newShortUrl(ctx.db);
 		const record = {
-			$type: "ovh.plonk.paste",
+			$type: "li.plonk.paste",
 			code: req.body?.code,
 			lang: req.body?.lang,
 			shortUrl,
···
 		try {
 			const res = await agent.com.atproto.repo.putRecord({
 				repo: agent.assertDid,
-				collection: "ovh.plonk.paste",
+				collection: "li.plonk.paste",
 				rkey,
 				record,
 				validate: false,
···
 					indexedAt: new Date().toISOString(),
 				})
 				.execute();
-			ctx.logger.info(res, "wrote back to db");
 			return res.redirect(`/p/${shortUrl}`);
 		} catch (err) {
 			ctx.logger.warn(
···
 
 		const rkey = TID.nextStr();
 		const record = {
-			$type: "ovh.plonk.comment",
+			$type: "li.plonk.comment",
 			content: req.body?.comment,
 			post: {
 				uri: pasteUri,
···
 		try {
 			const res = await agent.com.atproto.repo.putRecord({
 				repo: agent.assertDid,
-				collection: "ovh.plonk.comment",
+				collection: "li.plonk.comment",
 				rkey,
 				record,
 				validate: false,
···
 
 	return router;
 };
-
-// https://pds.icyphox.sh/xrpc/com.atproto.repo.getRecord?repo=did%3Aplc%3A3ft67n4xnawzq4qi7mcksxj5
-// at://did:plc:3ft67n4xnawzq4qi7mcksxj5/ovh.plonk.paste/3lcs3lnslbk2d
-// https://pds.icyphox.sh/xrpc/com.atproto.repo.getRecord?repo=did%3Aplc%3A3ft67n4xnawzq4qi7mcksxj5&collection=ovh.plonk.paste&rkey=3lcqt7newvc2c