@takosjp/yurucommu-core 3.0.0

package/src/db/schema/messaging.ts

@@ -0,0 +1,241 @@
+/**
+ * Messaging/DM tables: activities, inbox, deliveryQueue, deliveryCircuit,
+ * notificationArchived, dmTyping, dmReadStatus, dmArchivedConversations, mediaUploads
+ */
+
+import {
+  index,
+  integer,
+  primaryKey,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+import { nowIso, nowIsoUtc } from "./date-utils.ts";
+
+// ---------------------------------------------------------------------------
+// ACTIVITIES
+// ---------------------------------------------------------------------------
+
+export const activities = sqliteTable(
+  "activities",
+  {
+    apId: text("ap_id").primaryKey(),
+    type: text("type").notNull(),
+    actorApId: text("actor_ap_id").notNull(),
+    objectApId: text("object_ap_id"),
+    objectJson: text("object_json"),
+    targetApId: text("target_ap_id"),
+    rawJson: text("raw_json").notNull(),
+    direction: text("direction"),
+    processed: integer("processed").notNull().default(0),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    index("activities_actor_idx").on(t.actorApId),
+    index("activities_object_idx").on(t.objectApId),
+    index("activities_type_idx").on(t.type),
+    index("activities_type_created_idx").on(t.type, t.createdAt),
+    index("activities_dir_processed_idx").on(t.direction, t.processed),
+    index("activities_dir_proc_created_idx").on(
+      t.direction,
+      t.processed,
+      t.createdAt,
+    ),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// DELIVERY_QUEUE
+// ---------------------------------------------------------------------------
+
+export const deliveryQueue = sqliteTable(
+  "delivery_queue",
+  {
+    id: text("id").primaryKey(),
+    activityApId: text("activity_ap_id").notNull(),
+    inboxUrl: text("inbox_url").notNull(),
+    status: text("status").notNull().default("pending"),
+    attempts: integer("attempts").notNull().default(0),
+    lastAttemptAt: text("last_attempt_at"),
+    processingStartedAt: text("processing_started_at"),
+    nextAttemptAt: text("next_attempt_at").notNull().$defaultFn(nowIso),
+    deliveredAt: text("delivered_at"),
+    error: text("error"),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    index("delivery_queue_activity_idx").on(t.activityApId),
+    index("delivery_queue_next_attempt_idx").on(t.nextAttemptAt),
+    index("delivery_queue_status_next_idx").on(t.status, t.nextAttemptAt),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// DELIVERY_CIRCUIT
+// ---------------------------------------------------------------------------
+
+export const deliveryCircuit = sqliteTable(
+  "delivery_circuit",
+  {
+    endpoint: text("endpoint").primaryKey(),
+    state: text("state").notNull().default("closed"),
+    consecutiveFailures: integer("consecutive_failures").notNull().default(0),
+    recentOutcomesJson: text("recent_outcomes_json").notNull().default("[]"),
+    openUntil: text("open_until"),
+    halfOpenProbeAttempts: integer("half_open_probe_attempts")
+      .notNull()
+      .default(0),
+    halfOpenProbeSuccesses: integer("half_open_probe_successes")
+      .notNull()
+      .default(0),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+    updatedAt: text("updated_at")
+      .notNull()
+      .$defaultFn(nowIso)
+      .$onUpdateFn(nowIso),
+  },
+  (t) => [index("delivery_circuit_state_updated_idx").on(t.state, t.updatedAt)],
+);
+
+// ---------------------------------------------------------------------------
+// INBOX
+// ---------------------------------------------------------------------------
+
+export const inbox = sqliteTable(
+  "inbox",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    activityApId: text("activity_ap_id").notNull(),
+    read: integer("read").notNull().default(0),
+    // Canonical UTC (…Z): this column is the notification feed's sort + cursor
+    // key (`desc(created_at)`, `lt(created_at, before)`). The legacy
+    // space-separated `nowIso` would sort below same-instant `…Z` rows written
+    // by the explicit-`toISOString` insert paths (likes/reposts/replies),
+    // mis-ordering the feed. See nowIsoUtc.
+    createdAt: text("created_at").notNull().$defaultFn(nowIsoUtc),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.activityApId] }),
+    index("inbox_actor_read_created_idx").on(t.actorApId, t.read, t.createdAt),
+    // The notification-list query (WHERE actor_ap_id = ? ORDER BY created_at,
+    // activity_ap_id — no `read` constraint) cannot use the index above (its
+    // `read` column sits between the equality prefix and the sort key), so it
+    // filesorted the whole inbox. This composite serves the seek + sort directly.
+    index("inbox_actor_created_idx").on(
+      t.actorApId,
+      t.createdAt,
+      t.activityApId,
+    ),
+    index("inbox_activity_idx").on(t.activityApId),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// NOTIFICATION_ARCHIVED
+// ---------------------------------------------------------------------------
+
+export const notificationArchived = sqliteTable(
+  "notification_archived",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    activityApId: text("activity_ap_id").notNull(),
+    archivedAt: text("archived_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.activityApId] }),
+    index("notification_archived_actor_idx").on(t.actorApId),
+    index("notification_archived_actor_archived_idx").on(
+      t.actorApId,
+      t.archivedAt,
+    ),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// DM_TYPING
+// ---------------------------------------------------------------------------
+
+export const dmTyping = sqliteTable(
+  "dm_typing",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    recipientApId: text("recipient_ap_id").notNull(),
+    lastTypedAt: text("last_typed_at").notNull(),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.recipientApId] }),
+    index("dm_typing_recipient_typed_idx").on(t.recipientApId, t.lastTypedAt),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// DM_READ_STATUS
+// ---------------------------------------------------------------------------
+
+export const dmReadStatus = sqliteTable(
+  "dm_read_status",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    conversationId: text("conversation_id").notNull(),
+    lastReadAt: text("last_read_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.conversationId] }),
+    index("dm_read_status_actor_idx").on(t.actorApId),
+    index("dm_read_status_actor_read_idx").on(t.actorApId, t.lastReadAt),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// DM_COMMUNITY_READ_STATUS
+// ---------------------------------------------------------------------------
+
+export const dmCommunityReadStatus = sqliteTable(
+  "dm_community_read_status",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    communityApId: text("community_ap_id").notNull(),
+    lastReadAt: text("last_read_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.communityApId] }),
+    index("dm_community_read_status_actor_idx").on(t.actorApId),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// DM_ARCHIVED_CONVERSATIONS
+// ---------------------------------------------------------------------------
+
+export const dmArchivedConversations = sqliteTable(
+  "dm_archived_conversations",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    conversationId: text("conversation_id").notNull(),
+    archivedAt: text("archived_at").$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.conversationId] }),
+    index("dm_archived_conversations_actor_idx").on(t.actorApId),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// MEDIA_UPLOADS
+// ---------------------------------------------------------------------------
+
+export const mediaUploads = sqliteTable(
+  "media_uploads",
+  {
+    id: text("id").primaryKey(),
+    r2Key: text("r2_key").notNull().unique(),
+    uploaderApId: text("uploader_ap_id").notNull(),
+    contentType: text("content_type").notNull(),
+    size: integer("size").notNull(),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    index("media_uploads_uploader_idx").on(t.uploaderApId),
+    index("media_uploads_r2_key_idx").on(t.r2Key),
+  ],
+);

package/src/db/schema/mobile.ts

@@ -0,0 +1,37 @@
+/**
+ * Mobile client tables.
+ */
+
+import { index, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { nowIsoUtc } from "./date-utils.ts";
+import { actors } from "./actors.ts";
+
+export const mobilePushRegistrations = sqliteTable(
+  "mobile_push_registrations",
+  {
+    id: text("id").primaryKey(),
+    actorApId: text("actor_ap_id")
+      .notNull()
+      .references(() => actors.apId),
+    product: text("product").notNull(),
+    token: text("token").notNull(),
+    tokenHash: text("token_hash").notNull(),
+    environment: text("environment").notNull().default("production"),
+    hostUrl: text("host_url"),
+    createdAt: text("created_at").notNull().$defaultFn(nowIsoUtc),
+    updatedAt: text("updated_at")
+      .notNull()
+      .$defaultFn(nowIsoUtc)
+      .$onUpdateFn(nowIsoUtc),
+    lastSeenAt: text("last_seen_at").notNull().$defaultFn(nowIsoUtc),
+  },
+  (t) => [
+    uniqueIndex("mobile_push_registrations_actor_product_token_idx").on(
+      t.actorApId,
+      t.product,
+      t.tokenHash,
+    ),
+    index("mobile_push_registrations_actor_idx").on(t.actorApId),
+    index("mobile_push_registrations_last_seen_idx").on(t.lastSeenAt),
+  ],
+);

package/src/db/schema/posts.ts

@@ -0,0 +1,150 @@
+/**
+ * Post/Object-related tables: objects, likes, announces, bookmarks, objectRecipients
+ */
+
+import {
+  index,
+  integer,
+  primaryKey,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+import { nowIso } from "./date-utils.ts";
+
+// ---------------------------------------------------------------------------
+// OBJECTS
+// ---------------------------------------------------------------------------
+
+export const objects = sqliteTable(
+  "objects",
+  {
+    apId: text("ap_id").primaryKey(),
+    type: text("type").notNull().default("Note"),
+    attributedTo: text("attributed_to").notNull(),
+    content: text("content").notNull().default(""),
+    summary: text("summary"),
+    attachmentsJson: text("attachments_json").notNull().default("[]"),
+    inReplyTo: text("in_reply_to"),
+    conversation: text("conversation"),
+    visibility: text("visibility").notNull().default("public"),
+    toJson: text("to_json").notNull().default("[]"),
+    ccJson: text("cc_json").notNull().default("[]"),
+    audienceJson: text("audience_json").notNull().default("[]"),
+    tagsJson: text("tags_json").notNull().default("[]"),
+    communityApId: text("community_ap_id"),
+    endTime: text("end_time"),
+    likeCount: integer("like_count").notNull().default(0),
+    replyCount: integer("reply_count").notNull().default(0),
+    announceCount: integer("announce_count").notNull().default(0),
+    shareCount: integer("share_count").notNull().default(0),
+    published: text("published").notNull().$defaultFn(nowIso),
+    updated: text("updated"),
+    isLocal: integer("is_local").notNull().default(1),
+    rawJson: text("raw_json"),
+    deletedAt: text("deleted_at"),
+  },
+  (t) => [
+    index("objects_attributed_to_idx").on(t.attributedTo),
+    index("objects_in_reply_to_idx").on(t.inReplyTo),
+    index("objects_community_ap_id_idx").on(t.communityApId),
+    index("objects_published_idx").on(t.published),
+    index("objects_visibility_idx").on(t.visibility),
+    index("objects_end_time_idx").on(t.endTime),
+    index("objects_deleted_at_idx").on(t.deletedAt),
+    index("objects_attr_published_idx").on(t.attributedTo, t.published),
+    index("objects_vis_published_idx").on(t.visibility, t.published),
+    index("objects_type_vis_published_idx").on(
+      t.type,
+      t.visibility,
+      t.published,
+    ),
+    index("objects_conversation_idx").on(t.conversation),
+    // Composite for the DM message reader (where conversation=X order by
+    // published desc) so the hot, ~4s-polled thread endpoint reads in published
+    // order instead of filesorting the conversation's rows on every poll.
+    index("objects_conversation_published_idx").on(t.conversation, t.published),
+    index("objects_comm_published_idx").on(t.communityApId, t.published),
+    // Supports the B0.3 Story scope read path: active community-scoped stories
+    // (type='Story' AND community_ap_id=? AND end_time>?).
+    index("objects_type_comm_end_idx").on(t.type, t.communityApId, t.endTime),
+    index("objects_is_local_idx").on(t.isLocal),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// LIKES
+// ---------------------------------------------------------------------------
+
+export const likes = sqliteTable(
+  "likes",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    objectApId: text("object_ap_id").notNull(),
+    activityApId: text("activity_ap_id"),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.objectApId] }),
+    index("likes_object_idx").on(t.objectApId),
+    index("likes_actor_idx").on(t.actorApId),
+    index("likes_actor_object_idx").on(t.actorApId, t.objectApId),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// ANNOUNCES
+// ---------------------------------------------------------------------------
+
+export const announces = sqliteTable(
+  "announces",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    objectApId: text("object_ap_id").notNull(),
+    activityApId: text("activity_ap_id"),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.objectApId] }),
+    index("announces_object_idx").on(t.objectApId),
+    index("announces_actor_idx").on(t.actorApId),
+    index("announces_actor_object_idx").on(t.actorApId, t.objectApId),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// BOOKMARKS
+// ---------------------------------------------------------------------------
+
+export const bookmarks = sqliteTable(
+  "bookmarks",
+  {
+    actorApId: text("actor_ap_id").notNull(),
+    objectApId: text("object_ap_id").notNull(),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.actorApId, t.objectApId] }),
+    index("bookmarks_actor_idx").on(t.actorApId),
+  ],
+);
+
+// ---------------------------------------------------------------------------
+// OBJECT_RECIPIENTS
+// ---------------------------------------------------------------------------
+
+export const objectRecipients = sqliteTable(
+  "object_recipients",
+  {
+    objectApId: text("object_ap_id").notNull(),
+    recipientApId: text("recipient_ap_id").notNull(),
+    type: text("type").notNull(),
+    createdAt: text("created_at").notNull().$defaultFn(nowIso),
+  },
+  (t) => [
+    primaryKey({ columns: [t.objectApId, t.recipientApId] }),
+    index("object_recipients_recipient_created_idx").on(
+      t.recipientApId,
+      t.createdAt,
+    ),
+  ],
+);

package/src/db/schema/relations.ts

@@ -0,0 +1,266 @@
+/**
+ * Drizzle ORM Relations definitions
+ */
+
+import { relations } from "drizzle-orm";
+import { actorCache, actors, sessions } from "./actors.ts";
+import {
+  announces,
+  bookmarks,
+  likes,
+  objectRecipients,
+  objects,
+} from "./posts.ts";
+import { blocks, follows, mutes } from "./social.ts";
+import {
+  communities,
+  communityInvites,
+  communityJoinRequests,
+  communityMembers,
+} from "./communities.ts";
+import { storyShares, storyViews, storyVotes } from "./stories.ts";
+import { activities, inbox } from "./messaging.ts";
+
+// ===========================================================================
+// RELATIONS
+// ===========================================================================
+
+export const actorsRelations = relations(actors, ({ many }) => ({
+  sessions: many(sessions),
+  objectsAuthored: many(objects),
+  followsAsFollower: many(follows, { relationName: "followerFollows" }),
+  followsAsFollowing: many(follows, { relationName: "followingFollows" }),
+  likes: many(likes),
+  announces: many(announces),
+  bookmarks: many(bookmarks),
+  blocksAsBlocker: many(blocks, { relationName: "blockerBlocks" }),
+  blocksAsBlocked: many(blocks, { relationName: "blockedBlocks" }),
+  mutesAsMuter: many(mutes, { relationName: "muterMutes" }),
+  mutesAsMuted: many(mutes, { relationName: "mutedMutes" }),
+  activities: many(activities),
+  storyViews: many(storyViews),
+  storyVotes: many(storyVotes),
+  storyShares: many(storyShares),
+  communityMemberships: many(communityMembers),
+  communityJoinRequests: many(communityJoinRequests),
+  communityInvites: many(communityInvites),
+  inboxItems: many(inbox),
+  objectRecipients: many(objectRecipients),
+}));
+
+export const objectsRelations = relations(objects, ({ one, many }) => ({
+  author: one(actors, {
+    fields: [objects.attributedTo],
+    references: [actors.apId],
+  }),
+  community: one(communities, {
+    fields: [objects.communityApId],
+    references: [communities.apId],
+  }),
+  likes: many(likes),
+  announces: many(announces),
+  bookmarks: many(bookmarks),
+  storyViews: many(storyViews),
+  storyVotes: many(storyVotes),
+  storyShares: many(storyShares),
+  recipients: many(objectRecipients),
+  activities: many(activities),
+}));
+
+export const followsRelations = relations(follows, ({ one }) => ({
+  follower: one(actors, {
+    fields: [follows.followerApId],
+    references: [actors.apId],
+    relationName: "followerFollows",
+  }),
+  following: one(actors, {
+    fields: [follows.followingApId],
+    references: [actors.apId],
+    relationName: "followingFollows",
+  }),
+}));
+
+export const likesRelations = relations(likes, ({ one }) => ({
+  actor: one(actors, {
+    fields: [likes.actorApId],
+    references: [actors.apId],
+  }),
+  object: one(objects, {
+    fields: [likes.objectApId],
+    references: [objects.apId],
+  }),
+}));
+
+export const announcesRelations = relations(announces, ({ one }) => ({
+  actor: one(actors, {
+    fields: [announces.actorApId],
+    references: [actors.apId],
+  }),
+  object: one(objects, {
+    fields: [announces.objectApId],
+    references: [objects.apId],
+  }),
+}));
+
+export const bookmarksRelations = relations(bookmarks, ({ one }) => ({
+  actor: one(actors, {
+    fields: [bookmarks.actorApId],
+    references: [actors.apId],
+  }),
+  object: one(objects, {
+    fields: [bookmarks.objectApId],
+    references: [objects.apId],
+  }),
+}));
+
+export const blocksRelations = relations(blocks, ({ one }) => ({
+  blocker: one(actors, {
+    fields: [blocks.blockerApId],
+    references: [actors.apId],
+    relationName: "blockerBlocks",
+  }),
+  blocked: one(actors, {
+    fields: [blocks.blockedApId],
+    references: [actors.apId],
+    relationName: "blockedBlocks",
+  }),
+}));
+
+export const mutesRelations = relations(mutes, ({ one }) => ({
+  muter: one(actors, {
+    fields: [mutes.muterApId],
+    references: [actors.apId],
+    relationName: "muterMutes",
+  }),
+  muted: one(actors, {
+    fields: [mutes.mutedApId],
+    references: [actors.apId],
+    relationName: "mutedMutes",
+  }),
+}));
+
+export const activitiesRelations = relations(activities, ({ one, many }) => ({
+  actor: one(actors, {
+    fields: [activities.actorApId],
+    references: [actors.apId],
+  }),
+  object: one(objects, {
+    fields: [activities.objectApId],
+    references: [objects.apId],
+  }),
+  inboxItems: many(inbox),
+}));
+
+export const communitiesRelations = relations(communities, ({ many }) => ({
+  members: many(communityMembers),
+  objects: many(objects),
+  joinRequests: many(communityJoinRequests),
+  invites: many(communityInvites),
+}));
+
+export const communityMembersRelations = relations(
+  communityMembers,
+  ({ one }) => ({
+    community: one(communities, {
+      fields: [communityMembers.communityApId],
+      references: [communities.apId],
+    }),
+    actor: one(actors, {
+      fields: [communityMembers.actorApId],
+      references: [actors.apId],
+    }),
+  }),
+);
+
+export const communityJoinRequestsRelations = relations(
+  communityJoinRequests,
+  ({ one }) => ({
+    community: one(communities, {
+      fields: [communityJoinRequests.communityApId],
+      references: [communities.apId],
+    }),
+    actor: one(actors, {
+      fields: [communityJoinRequests.actorApId],
+      references: [actors.apId],
+    }),
+  }),
+);
+
+export const communityInvitesRelations = relations(
+  communityInvites,
+  ({ one }) => ({
+    community: one(communities, {
+      fields: [communityInvites.communityApId],
+      references: [communities.apId],
+    }),
+    invitedBy: one(actors, {
+      fields: [communityInvites.invitedByApId],
+      references: [actors.apId],
+    }),
+  }),
+);
+
+export const objectRecipientsRelations = relations(
+  objectRecipients,
+  ({ one }) => ({
+    object: one(objects, {
+      fields: [objectRecipients.objectApId],
+      references: [objects.apId],
+    }),
+    recipient: one(actors, {
+      fields: [objectRecipients.recipientApId],
+      references: [actors.apId],
+    }),
+  }),
+);
+
+export const inboxRelations = relations(inbox, ({ one }) => ({
+  actor: one(actors, {
+    fields: [inbox.actorApId],
+    references: [actors.apId],
+  }),
+  activity: one(activities, {
+    fields: [inbox.activityApId],
+    references: [activities.apId],
+  }),
+}));
+
+export const sessionsRelations = relations(sessions, ({ one }) => ({
+  member: one(actors, {
+    fields: [sessions.memberId],
+    references: [actors.apId],
+  }),
+}));
+
+export const storyViewsRelations = relations(storyViews, ({ one }) => ({
+  actor: one(actors, {
+    fields: [storyViews.actorApId],
+    references: [actors.apId],
+  }),
+  story: one(objects, {
+    fields: [storyViews.storyApId],
+    references: [objects.apId],
+  }),
+}));
+
+export const storyVotesRelations = relations(storyVotes, ({ one }) => ({
+  actor: one(actors, {
+    fields: [storyVotes.actorApId],
+    references: [actors.apId],
+  }),
+  story: one(objects, {
+    fields: [storyVotes.storyApId],
+    references: [objects.apId],
+  }),
+}));
+
+export const storySharesRelations = relations(storyShares, ({ one }) => ({
+  actor: one(actors, {
+    fields: [storyShares.actorApId],
+    references: [actors.apId],
+  }),
+  story: one(objects, {
+    fields: [storyShares.storyApId],
+    references: [objects.apId],
+  }),
+}));