refine work + chapter structures

db/config.ts

···
     tags: column.json(),
     createdAt: column.date({ name: "created_at", default: NOW }),
     updatedAt: column.date({ name: "updated_at", optional: true }),
+    draft: column.boolean({ default: true }),
   },
   indexes: [
     { on: ["author", "slug"], unique: true },
     { on: ["slug", "createdAt"], unique: true },
-    { on: ["uri", "createdAt"], unique: true },
   ],
 });
 
···
     id: column.number({ primaryKey: true }),
     uri: column.text({ optional: true }),
     workId: column.number({ references: () => Works.columns.id }),
-    // order: column.number(), // i don't think this is needed...
+    slug: column.text({ unique: true }),
     title: column.text(),
+    warnings: column.text({ multiline: true, optional: true }),
     notes: column.text({ multiline: true, optional: true }),
-    content: column.text({ multiline: true }),
+    content: column.json(),
     createdAt: column.date({ name: "created_at", default: NOW }),
     updatedAt: column.date({ name: "updated_at", optional: true }),
+    draft: column.boolean({ default: true }),
   },
+  indexes: [
+    { on: ["workId", "slug"], unique: true },
+    { on: ["workId", "createdAt"], unique: true },
+  ]
 });
 
 const Tags = defineTable({

db/seed.ts

···
       author: "test", 
       title: "Hey there title",
       summary: "<p>i have evil html</p>",
-      tags: [{ label: "test", url: "#" }],
+      tags: [{ label: "test", slug: "#", type: "character" }],
     },
     { 
       slug: "1235",
       author: "another", 
       title: "Hello world",
       summary: "<p>whoag i have <b>BOLD</b></p>",
-      tags: [{ label: "label", url: "#" }],
+      tags: [{ label: "label", slug: "#", type: "relationship" }, { label: "label", slug: "#", type: "character" }],
     },
     {
       uri: "at://did:plc:dg2qmmjic7mmecrbvpuhtvh6/moe.fanfics.works/3lyeiyq32ek2o",
···
   await db.insert(Chapters).values([
     {
       workId: 1,
-      // order: 1,
+      slug: `${new Date().valueOf().toString()}-1`,
       title: "chapter title 1",
       content: "what's up?! <b>bold</b> and <em>italics</em> should work.",
     },
     {
       workId: 2,
-      // order: 1,
+      slug: `${new Date().valueOf().toString()}-2`,
       title: "chapter title 2",
       content: "test",
     },
     {
       workId: 3,
-      // order: 1,
+      slug: `${new Date().valueOf().toString()}-3`,
       title: "at proto",
       content: "what's up?! <b>bold</b> and <em>italics</em> should work.",
     }

lexicons/fan/fics/work.json

···
             "maxLength": 3000,
             "maxGraphemes": 3000
           },
+          "chapters": {
+            "type": "array",
+            "items": {
+              "type": "ref",
+              "ref": "fan.fics.work.chapter"
+            }
+          },
           "createdAt": {
             "type": "string",
             "format": "datetime"

src/actions/works/addWork.ts

···
 import { ActionError, defineAction } from "astro:actions";
-import { db, eq, Users, Works } from "astro:db";
+import { Chapters, db, eq, Users, Works } from "astro:db";
 import { z } from "astro:schema";
-import { AtUri } from "@atproto/api";
-import { TID } from "@atproto/common-web";
-import { customAlphabet } from "nanoid";
-import { callSlices, fetchBskyPost, fetchLeaflet, getAgent } from "@/lib/atproto";
-import { addChapter, updateWork } from "@/lib/db";
+import { customAlphabet, nanoid } from "nanoid";
+import { createFanficWork, importChapter } from "@/lib/atproto";
 import schema from "./schema";
+import type { BskyPost, ChapterText, LeafletDoc } from "@/lib/types";
 
 export default defineAction({
   accept: "form",
-  input: schema.extend({
-    option: z.enum(["manual", "bsky", "leaflet"]),
-    bskyUri: z.string().optional(),
-    leafletUri: z.string().optional(),
-    chapterTitle: z.string().optional(),
-    content: z.string().optional(),
-    notes: z.string().optional(),
-  }),
-  handler: async (
-    // yeah this is fucking insane
-    {
-      title,
-      summary, 
-      tags, 
-      option, 
-      bskyUri, 
-      leafletUri, 
-      chapterTitle, 
-      content, 
-      notes, 
-      publish 
-    }, context) => {
+  input: schema,
+  handler: async ({ title, summary, tags, publish }, context) => {
     const loggedInUser = context.locals.loggedInUser;
 
     //#region "Check authentication"
···
     };
     //#endregion
     
-    //#region "Import chapter from Bluesky or Leaflet"
-    if (option !== "manual") {
-      if (bskyUri) {
-        const result = await fetchBskyPost(bskyUri);
-        console.log("bsky post: " + JSON.stringify(result));
-      }
-      if (leafletUri) {
-        const result = await fetchLeaflet(leafletUri);
-        console.log("leaflet: " + JSON.stringify(result));
-      }
-    }
-    //#endregion
-    
     //#region "Start publishing work to ATProto"
     // we'll assign this after a successful request was made
     let uri: string | undefined;
-    let cUri: string | undefined;
+    // let cUri: string | undefined;
     
     if (publish) {
       try {
-        const rkey = TID.nextStr();
         const { tags, ...rest } = record;
         
-        const result = await callSlices(
-          "work",
-          "createRecord",
-          rkey,
-          {
-            ...rest,
-            tags: [tags],
-            author: loggedInUser.did,
-            createdAt: createdAt.toISOString()
-          }
-        );
+        const result = await createFanficWork({
+          ...rest,
+          tags: [tags],
+          author: loggedInUser.did,
+          createdAt: createdAt.toISOString(),
+        });
         
         console.log(JSON.stringify(result));
         if (result.error) {
-          console.error(`this went wrong for WORK: ${result.message}`);
           throw new ActionError({
             code: "BAD_REQUEST",
-            message: "Something went wrong!",
+            message: "Something went wrong with posting your fic to your PDS!",
           });
         }
         uri = result.uri;
-
-        //#region "Publish the first chapter with the work to ATProto"
-        // ONLY proceed if the uri is set from successfully adding a work
-        if (uri) {
-          const crkey = TID.nextStr(rkey);
-          let chapterContent = {};
-                  
-          if (option === "manual") {
-            chapterContent = {
-              $type: "fan.fics.work.chapter#chapterText",
-              text: content,
-            };
-          }
-
-          const chapter = await callSlices(
-            "work.chapter",
-            "createRecord",
-            crkey,
-            {
-              title: chapterTitle,
-              content: chapterContent,
-              createdAt: createdAt.toISOString(),
-              workUri: uri,
-            }
-          );
-
-          console.log(JSON.stringify(chapter));
-          if (chapter.error) {
-            console.error(`this went wrong: ${chapter.message}`);
-            throw new ActionError({
-              code: "BAD_REQUEST",
-              message: "Something went wrong!",
-            });
-          }
-          cUri = chapter.uri;
-          //#endregion
-        }
       } catch (error) {
         console.error(error);
         throw new ActionError({
···
     //#region "Add a new work to the database"
     // check nanoid for collision probability: https://zelark.github.io/nano-id-cc/
     const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-    const nanoid = customAlphabet(alphabet, 16);
-    const slug = nanoid();
-
+    const custom = customAlphabet(alphabet, 16);
+    const slug = custom();
+    
     const [work] = await db.insert(Works).values({
       uri,
       slug,
       createdAt,
       author: user.did,
       ...record,
-    }).returning();
+    }).onConflictDoNothing({ target: Works.slug }).returning();
 
-    if (chapterTitle && content) {
-      try {
-        await addChapter(
-          work.id,
-          chapterTitle,
-          content,
-          cUri,
-          notes,
-        );
-      } catch (error) {
-        console.error(error);
-        throw new ActionError({
-          code: "BAD_REQUEST",
-          message: "Something went wrong!",
-        });
-      }
-    }
-    
     return work;
+    // const newWork = await db.transaction(async (tx) => {
+    //   const [work] = await tx.insert(Works).values({
+    //     uri,
+    //     slug,
+    //     createdAt,
+    //     author: user.did,
+    //     ...record,
+    //   }).onConflictDoNothing({ target: Works.slug }).returning();
+    //   if (!work) { tx.rollback(); }
+    //   const [chapter] = await tx.insert(Chapters).values({
+    //     workId: work.id,
+    //     slug: nanoid(),
+    //     title: chapterTitle!,
+    //     content: content!,
+    //     uri: cUri,
+    //     authorsNotes: notes,
+    //   }).onConflictDoNothing({ target: Chapters.id }).returning();
+    //   if (!chapter) { tx.rollback(); }
+    //   return work;
+    // });
+    // return newWork;
     //#endregion
   },
 });

src/components/chapters/Chapter.astro

···
 <section>
   <header>
     <h1>{chapter.title}</h1>
-    {chapter.authorsNotes && (
+    {chapter.warnings && (
       <details>
-        <summary>Author's Notes</summary>
-        <Fragment set:html={chapter.authorsNotes} />
+        <summary>Content warnings</summary>
+        <Fragment set:html={chapter.warnings} />
       </details>
     )}
     <time datetime={chapter.createdAt.toISOString()}>
···
   </div>
 
   <footer>
-    {chapter.endNotes && (
+    {chapter.notes && (
       <aside>
-        <p>End notes</p>
-        <Fragment set:html={chapter.endNotes} />
+        <p>Author's Notes</p>
+        <Fragment set:html={chapter.notes} />
       </aside>
     )}
   </footer>

src/lib/db.ts

···
 import slugify from "@sindresorhus/slugify";
 import { and, Chapters, db, eq, Tags, Works } from "astro:db";
 import type { Chapter } from "./types";
+import { SQLiteOAuthStorage } from "@slices/oauth";
+
+
+const OAUTH_CLIENT_ID = import.meta.env.OAUTH_CLIENT_ID;
+const OAUTH_CLIENT_SECRET = import.meta.env.OAUTH_CLIENT_SECRET;
+const OAUTH_REDIRECT_URI = import.meta.env.OAUTH_REDIRECT_URI;
+const OAUTH_AIP_BASE_URL = import.meta.env.OAUTH_AIP_BASE_URL;
+const API_URL = import.meta.env.API_URL;
+export const SLICE_URI = import.meta.env.SLICE_URI;
+
+// oauth session
+// const DATABASE_URL = import.meta.env.DATABASE_URL || "slices.db";
+// const oauthStorage = new SQLiteOAuthStorage(DATABASE_URL);
+// const oauthConfig = {
+//   clientId: OAUTH_CLIENT_ID,
+//   clientSecret: OAUTH_CLIENT_SECRET,
+//   authBaseUrl: OAUTH_AIP_BASE_URL,
+//   redirectUri: OAUTH_REDIRECT_URI,
+//   scopes: ["atproto", "openid", "profile", "transition:generic"],
+// };
 
 // fetch tags
 export async function searchTags(search: string) {
···
       workId,
       uri,
       title,
+      slug: "",
       // order,
       notes,
       content,
···
       eq(Works.id, chapter.workId),
       eq(Chapters.id, chapter.id)
     ));
-}
+}
+

src/lib/types.ts

···
 export type Work = typeof Works.$inferSelect;
 export type Chapter = typeof Chapters.$inferSelect;
 export type Tag = typeof Tags.$inferSelect;
-export type User = typeof Users.$inferSelect;
+export type User = typeof Users.$inferSelect;
+
+export type atProtoWork = Omit<Work, "id" | "slug"> | {
+  createdAt: string;
+  updatedAt?: string;
+};
+
+export type atProtoChapter = Omit<Chapter, "id" | "uri" | "slug" | "workId"> | {
+  workUri: string;
+  chapterRef?: string;
+  content: ChapterText | BskyPost | LeafletDoc;
+  createdAt: string;
+  updatedAt?: string;
+};
+
+export type atProtoComment = {
+  content: string;
+  createdAt: string;
+  postedTo?: string;
+};
+
+type comAtProtoStrongRef = {
+  uri: string;
+  cid: string;
+};
+
+export type ChapterText = {
+  $type: "fan.fics.work.chapter#chapterText";
+  text: string;
+};
+
+export type BskyPost = {
+  $type: "fan.fics.work.chapter#bskyPost";
+  postRef: comAtProtoStrongRef;
+};
+
+export type LeafletDoc = {
+  $type: "fan.fics.work.chapter#leafletDoc";
+  docRef: comAtProtoStrongRef;
+};

src/middleware.ts

···
 
 export const onRequest = defineMiddleware(async (context, next) => {
   if (context.isPrerendered) return next();
+  // context.session?.set("oauth", "hey") // figure this out
+
   const { action, setActionResult, serializeActionResult } = getActionContext(context);
-
   const latestAction = await context.session?.get("latest-action");
   if (latestAction) {
     setActionResult(latestAction.name, latestAction.result);