Update outbox format

src/entities/export.ts

@@ -1,14 +1,16 @@
+import { type Actor, lookupObject } from "@fedify/fedify";
 import { exportActorProfile } from "@interop/wallet-export-ts";
 import { eq } from "drizzle-orm";
 import type { Context } from "hono";
 import db from "../db";
 import * as schema from "../schema";
 import { serializeAccount } from "./account";
 import { serializeList } from "./list";
-import { getPostRelations, serializePost } from "./status";
+import { generateOutbox } from "./outbox";
+import { getPostRelations } from "./status";
+
+const homeUrl = process.env["HOME_URL"] || "http://localhost:3000";
 
-// biome-ignore lint/complexity/useLiteralKeys: <explanation>
-const homeUrl = process.env["HOME_URL"] || "http://localhost:3000/";
 // Account Exporter class to handle data loading and serialization
 export class AccountExporter {
   actorId: ActorIdType;
@@ -111,9 +113,13 @@ export class AccountExporter {
       if (!account) return c.json({ error: "Actor not found" }, 404);
 
       const postsData = await this.loadPosts();
-      const serializedPosts = postsData.map((post) =>
-        serializePost(post, { id: account.owner.id }, c.req.url),
-      );
+      console.log("🚀 ~ AccountExporter ~ exportData ~ postsData:", postsData);
+
+      const actor = (await lookupObject(account.iri)) as Actor;
+
+      const outbox = await generateOutbox(actor, new URL(homeUrl));
+
+      console.log("🚀 ~ AccountExporter ~ exportData ~ outbox:", outbox);
 
       const lists = await this.loadLists();
       const serializedLists = lists.map((list) => serializeList(list));
@@ -133,7 +139,7 @@ export class AccountExporter {
           { ...account, successor: null },
           c.req.url,
         ),
-        outbox: serializedPosts,
+        outbox: outbox,
         lists: serializedLists,
         followers: serializedFollowers,
         followingAccounts: serializedFollowing,

src/entities/import.ts

@@ -223,19 +223,30 @@ export class AccountImporter {
     );
   }
 
-  async importOutbox(post: Post) {
-    console.log("🚀 ~ AccountImporter ~ importOutbox ~ post:", post);
+  async importOutbox(activity: any) {
+    console.log("🚀 ~ AccountImporter ~ importOutbox ~ activity:", activity);
     try {
+      // Validate the activity object
+      if (!activity.object || activity.type !== "Create") {
+        console.error(
+          "Skipping activity due to invalid type or missing object:",
+          activity,
+        );
+        return;
+      }
+
+      const post = activity.object; // The `Note` object inside the `Create` activity
+
       // Validate the post object
-      if (!post.url || !post.type || !post.created_at || !post.content) {
+      if (!post.id || !post.type || !post.published || !post.content) {
         console.error("Skipping post due to missing required fields:", post);
         return;
       }
 
       // Generate a new post ID using cuuid
       const postDataCanonical = canonicalize({
-        uri: post.url, // Use post.url instead of post.iri
-        createdAt: post.created_at,
+        uri: post.id, // Use post.id as the unique identifier
+        createdAt: post.published,
         accountId: this.actorId, // Use the new account ID
       });
 
@@ -247,41 +258,43 @@ export class AccountImporter {
       const newPostId = await cuuid.toString();
 
       // Log the post URL for debugging
-      console.log("🚀 ~ AccountImporter ~ importOutbox ~ post.url:", post.url);
+      console.log("🚀 ~ AccountImporter ~ importOutbox ~ post.id:", post.id);
 
       // Check if the post already exists
       const isExistingPost = await db.query.posts.findFirst({
-        where: eq(schema.posts.iri, post.url), // Check by URL (iri)
+        where: eq(schema.posts.iri, post.id), // Check by post.id (iri)
       });
 
       if (isExistingPost) {
         console.warn(
-          `Post with URL ${post.url} already exists, updating instead of skipping`,
+          `Post with ID ${post.id} already exists, updating instead of skipping`,
         );
       }
 
       const postData = {
         id: newPostId,
-        iri: post.url,
+        iri: post.id, // Use post.id as the unique identifier
         type: post.type,
         accountId: this.actorId,
-        createdAt: new Date(post.created_at),
-        inReplyToId: post.in_reply_to_id || null,
+        createdAt: new Date(post.published),
+        inReplyToId: post.inReplyTo
+          ? new URL(post.inReplyTo).pathname.split("/").pop()
+          : null, // Extract ID from inReplyTo URL
         sensitive: post.sensitive || false,
-        spoilerText: post.spoiler_text || "",
-        visibility: post.visibility || "public",
-        language: post.language || "en",
-        url: post.url,
-        repliesCount: post.replies_count || 0,
-        reblogsCount: post.reblogs_count || 0,
-        favouritesCount: post.favourites_count || 0,
-        favourited: post.favourited || false,
-        reblogged: post.reblogged || false,
-        muted: post.muted || false,
-        bookmarked: post.bookmarked || false,
-        pinned: post.pinned || false,
+        spoilerText: post.summary || "", // Use post.summary as spoilerText
+        visibility: "public" as "public" | "unlisted" | "private" | "direct",
+        language: post.contentMap?.en ? "en" : "und",
+        url: post.url || post.id,
+        repliesCount: post.replies?.totalItems || 0,
+        reblogsCount: post.shares?.totalItems || 0,
+        favouritesCount: post.likes?.totalItems || 0,
+        favourited: false, // Default value
+        reblogged: false, // Default value
+        muted: false, // Default value
+        bookmarked: false, // Default value
+        pinned: false, // Default value
         contentHtml: post.content,
-        quoteId: post.quote_id || null,
+        quoteId: null, // Default value (no quote support yet)
       };
 
       // Insert or update the post

src/entities/outbox.ts

@@ -0,0 +1,149 @@
+import {
+  Activity,
+  type Actor,
+  type Object as FedifyObject,
+} from "@fedify/fedify";
+import { iterateCollection } from "../federation/collection";
+
+// Helper to get tags as an array
+async function getTagsAsArray(
+  object: FedifyObject,
+): Promise<Array<{ type: string; href: string; name: string }>> {
+  const tags = [];
+  for await (const tag of object.getTags() as any) {
+    tags.push({
+      type: tag.id?.toString(),
+      href: tag.href?.toString(),
+      name: tag.name,
+    });
+  }
+  return tags;
+}
+
+async function getRepliesAsArray(object: any): Promise<Array<{ id: string; type: string, totalItems: number }>> {
+  if (!object?.getReplies) return [];
+  const replies = [];
+  for await (const reply of object.getReplies()) {
+    const id = safeToString(reply.id);
+    const type = safeToString(reply.typeId);
+    if (id && type) {
+      replies.push({
+        id,
+        type,
+        totalItems: reply.totalItems,
+      });
+    }
+  }
+  return replies.filter((reply) => reply.id && reply.type); // Remove incomplete entries
+}
+
+async function fetchOutbox(actor: Actor) {
+  const outbox = await actor.getOutbox();
+  console.log("🚀 ~ fetchOutbox ~ outbox:", outbox);
+  if (!outbox) return null;
+
+  const activities: Activity[] = [];
+  for await (const activity of iterateCollection(outbox)) {
+    if (activity instanceof Activity) {
+      activities.push(activity);
+    }
+  }
+
+  console.log("🚀 ~ fetchOutbox ~ activities:", activities);
+  return activities;
+}
+
+function safeToString(value: unknown): string | undefined {
+  return value?.toString();
+}
+
+function cleanObject(obj: Record<string, any>): Record<string, any> {
+  const cleaned: Record<string, any> = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== null && value !== undefined) {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+
+async function generateOutbox(actor: Actor, baseUrl: string | URL) {
+  const activities = await fetchOutbox(actor);
+  if (!activities) return null;
+
+  const outbox = {
+    "@context": [
+      "https://www.w3.org/ns/activitystreams",
+      "https://w3id.org/security/v1",
+    ],
+    id: new URL("/outbox.json", baseUrl).toString(),
+    type: "OrderedCollection",
+    totalItems: activities.length,
+    orderedItems: await Promise.all(
+      activities.map(async (activity) => {
+        console.log("🚀 ~ Processing activity:", activity);
+
+        const object = await activity.getObject();
+        console.log("🚀 ~ Retrieved object:", object);
+
+        if (!object) {
+          console.log("🚀 ~ Object is null, skipping activity");
+          return null;
+        }
+
+        const replies = await object.getReplies();
+        console.log("🚀 ~ activities.map ~ replies:", replies)
+        const likes = await object.getLikes();
+        console.log("🚀 ~ activities.map ~ likes:", likes)
+        const shares = await object.getShares();
+        console.log("🚀 ~ activities.map ~ shares:", shares
+
+        )
+        const to = object.toIds;
+        const cc = object.ccIds;
+
+        const tags = await getTagsAsArray(object);
+
+        const fullObject = cleanObject({
+          id: safeToString(object.id),
+          type: safeToString(object.id),
+          content: object.content,
+          published: safeToString(object.published),
+          url: safeToString(object.url),
+          to: to.length > 0 ? to : undefined,
+          cc: cc.length > 0 ? cc : undefined,
+          tags: tags.length > 0 ? tags : undefined,
+          replies: {
+            id: replies?.id,
+            totalITems: replies?.totalItems,
+            items: replies?.getItems
+          },
+          likes: {
+            id: likes?.id,
+            totalItems: likes?.totalItems,
+            items: likes?.getItems
+          },
+          shares: {
+            id: shares?.id,
+            totalItems: shares?.totalItems,
+            items: shares?.getItems
+          },
+        });
+
+        return cleanObject({
+          id: safeToString(activity.id),
+          type: "OrderedCollection",
+          actor: safeToString(activity.actorId),
+          published: safeToString(activity.published),
+          to: activity.toIds,
+          cc: activity.ccIds,
+          object: fullObject,
+        });
+      }),
+    ).then((items) => items.filter(Boolean)), // Remove null entries
+  };
+
+  return outbox;
+}
+
+export { generateOutbox };

src/types/account.d.ts

@@ -32,45 +32,32 @@ interface ActorProfile {
 
 // Define an interface for a Post
 interface Post {
-  id: string | SQL<unknown> | ActorIdType;
+  id: string;
   iri: string;
-  created_at: string;
-  in_reply_to_id: null | string;
-  type: SQL<unknown> | "Article" | "Note" | "Question" | undefined;
+  type: string;
+  accountId: string;
+  applicationId: string | null; // Allow null
+  replyTargetId?: string | null;
+  sharingId?: string | null;
+  quoteTargetId?: `${string}-${string}-${string}-${string}-${string}` | null;
+  visibility: string;
+  summary?: string | null;
+  contentHtml?: string | null;
+  content?: string | null;
+  pollId?: string | null;
+  language?: string | null;
+  tags: Record<string, string>;
+  emojis: Record<string, string>;
   sensitive: boolean;
-  spoiler_text: string;
-  visibility:
-    | SQL<unknown>
-    | "public"
-    | "unlisted"
-    | "private"
-    | "direct"
-    | undefined;
-  language: string;
-  uri: string;
-  url: null | string;
-  replies_count: number;
-  reblogs_count: number;
-  favourites_count: number;
-  favourited: boolean;
-  reblogged: boolean;
-  muted: boolean;
-  bookmarked: boolean;
-  pinned: boolean;
-  content: string;
-  reblog: null | Post;
-  quote_id: null | string;
-  quote: null | Post;
-  application: null | string;
-  account: ActorProfile;
-  media_attachments: Array<{ url: string }>;
-  mentions: Array<{ username: string; url: string }>;
-  tags: Array<{ name: string }>;
-  card: null | { url: string; title: string; description: string };
-  emojis: Array<{ shortcode: string; url: string }>;
-  emoji_reactions: Array<{ emoji: string; count: number }>;
-  poll: null | { options: Array<{ title: string; votes_count: number }> };
-  filtered: null | Array<{ filter: string }>;
+  url?: string | null;
+  previewCard?: any | null;
+  repliesCount: number;
+  sharesCount: number;
+  likesCount: number;
+  idempotenceKey?: string;
+  published?: Date | null;
+  updated: Date;
+  media?: Array<{ id: string; url: string; contentType: string }> | null;
 }
 
 // Define an interface for FollowersData