feat(federation): ✨ Port to Versia 0.6

packages/sdk/schemas/collection.ts

@@ -1,16 +1,13 @@
 import { z } from "zod";
-import { u64, url } from "./common.ts";
+import { u64 } from "./common.ts";
+import { ReferenceSchema } from "./entity.ts";
 
 export const CollectionSchema = z.strictObject({
-    author: url.nullable(),
-    first: url,
-    last: url,
+    author: ReferenceSchema.nullable(),
     total: u64,
-    next: url.nullable(),
-    previous: url.nullable(),
     items: z.array(z.any()),
 });
 
 export const URICollectionSchema = CollectionSchema.extend({
-    items: z.array(url),
+    items: z.array(ReferenceSchema),
 });

packages/sdk/schemas/contentformat.ts

@@ -2,26 +2,6 @@ import { types } from "mime-types";
 import { z } from "zod";
 import { f64, u64 } from "./common.ts";
 
-const hashSizes = {
-    sha256: 64,
-    sha512: 128,
-    "sha3-256": 64,
-    "sha3-512": 128,
-    "blake2b-256": 64,
-    "blake2b-512": 128,
-    "blake3-256": 64,
-    "blake3-512": 128,
-    md5: 32,
-    sha1: 40,
-    sha224: 56,
-    sha384: 96,
-    "sha3-224": 56,
-    "sha3-384": 96,
-    "blake2s-256": 64,
-    "blake2s-512": 128,
-    "blake3-224": 56,
-    "blake3-384": 96,
-};
 const allMimeTypes = Object.values(types) as [string, ...string[]];
 const textMimeTypes = Object.values(types).filter((v) =>
     v.startsWith("text/"),
@@ -46,16 +26,7 @@ export const ContentFormatSchema = z.partialRecord(
         remote: z.boolean(),
         description: z.string().nullish(),
         size: u64.nullish(),
-        hash: z
-            .strictObject(
-                Object.fromEntries(
-                    Object.entries(hashSizes).map(([k, v]) => [
-                        k,
-                        z.string().length(v).nullish(),
-                    ]),
-                ),
-            )
-            .nullish(),
+        hash: z.hash("sha256").nullish(),
         thumbhash: z.string().nullish(),
         width: u64.nullish(),
         height: u64.nullish(),

packages/sdk/schemas/delete.ts

@@ -1,11 +1,9 @@
 import { z } from "zod";
-import { url } from "./common.ts";
-import { EntitySchema } from "./entity.ts";
+import { ReferenceSchema, TransientEntitySchema } from "./entity.ts";
 
-export const DeleteSchema = EntitySchema.extend({
-    uri: z.null().optional(),
+export const DeleteSchema = TransientEntitySchema.extend({
     type: z.literal("Delete"),
-    author: url.nullable(),
+    author: ReferenceSchema,
     deleted_type: z.string(),
-    deleted: url,
+    deleted: ReferenceSchema,
 });

packages/sdk/schemas/entity.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { isISOString } from "../regex.ts";
-import { url } from "./common.ts";
 import { CustomEmojiExtensionSchema } from "./extensions/emojis.ts";
 
 export const ExtensionPropertySchema = z
@@ -10,14 +9,26 @@ export const ExtensionPropertySchema = z
     })
     .catchall(z.any());
 
+export const ReferenceSchema = z.string();
+
 export const EntitySchema = z.strictObject({
     // biome-ignore lint/style/useNamingConvention: required for JSON schema
     $schema: z.url().nullish(),
-    id: z.string().max(512),
+    id: z
+        .string()
+        .max(512)
+        .regex(
+            // a-z, A-Z, 0-9, - and _
+            /^[A-Za-z0-9\-_]+$/,
+            "can only contain alphanumeric characters, hyphens and underscores",
+        ),
     created_at: z
         .string()
-        .refine((v) => isISOString(v), "must be a valid ISO8601 datetime"),
-    uri: url,
+        .refine((v) => isISOString(v), "must be a valid RFC 3339 datetime"),
     type: z.string(),
     extensions: ExtensionPropertySchema.nullish(),
 });
+
+export const TransientEntitySchema = EntitySchema.extend({
+    id: z.null().optional(),
+});

packages/sdk/schemas/extensions/groups.ts

@@ -1,41 +1,38 @@
 import { z } from "zod";
-import { url } from "../common.ts";
 import { TextContentFormatSchema } from "../contentformat.ts";
-import { EntitySchema } from "../entity.ts";
+import {
+    EntitySchema,
+    ReferenceSchema,
+    TransientEntitySchema,
+} from "../entity.ts";
 
 export const GroupSchema = EntitySchema.extend({
     type: z.literal("pub.versia:groups/Group"),
     name: TextContentFormatSchema.nullish(),
     description: TextContentFormatSchema.nullish(),
-    open: z.boolean().nullish(),
-    members: url,
-    notes: url.nullish(),
+    open: z.boolean(),
 });
 
-export const GroupSubscribeSchema = EntitySchema.extend({
+export const GroupSubscribeSchema = TransientEntitySchema.extend({
     type: z.literal("pub.versia:groups/Subscribe"),
-    uri: z.null().optional(),
-    subscriber: url,
-    group: url,
+    subscriber: ReferenceSchema,
+    group: ReferenceSchema,
 });
 
-export const GroupUnsubscribeSchema = EntitySchema.extend({
+export const GroupUnsubscribeSchema = TransientEntitySchema.extend({
     type: z.literal("pub.versia:groups/Unsubscribe"),
-    uri: z.null().optional(),
-    subscriber: url,
-    group: url,
+    subscriber: ReferenceSchema,
+    group: ReferenceSchema,
 });
 
-export const GroupSubscribeAcceptSchema = EntitySchema.extend({
+export const GroupSubscribeAcceptSchema = TransientEntitySchema.extend({
     type: z.literal("pub.versia:groups/SubscribeAccept"),
-    uri: z.null().optional(),
-    subscriber: url,
-    group: url,
+    subscriber: ReferenceSchema,
+    group: ReferenceSchema,
 });
 
-export const GroupSubscribeRejectSchema = EntitySchema.extend({
+export const GroupSubscribeRejectSchema = TransientEntitySchema.extend({
     type: z.literal("pub.versia:groups/SubscribeReject"),
-    uri: z.null().optional(),
-    subscriber: url,
-    group: url,
+    subscriber: ReferenceSchema,
+    group: ReferenceSchema,
 });

packages/sdk/schemas/extensions/likes.ts

@@ -1,15 +1,14 @@
 import { z } from "zod";
-import { url } from "../common.ts";
-import { EntitySchema } from "../entity.ts";
+import { EntitySchema, ReferenceSchema } from "../entity.ts";
 
 export const LikeSchema = EntitySchema.extend({
     type: z.literal("pub.versia:likes/Like"),
-    author: url,
-    liked: url,
+    author: ReferenceSchema,
+    liked: ReferenceSchema,
 });
 
 export const DislikeSchema = EntitySchema.extend({
     type: z.literal("pub.versia:likes/Dislike"),
-    author: url,
-    disliked: url,
+    author: ReferenceSchema,
+    disliked: ReferenceSchema,
 });

packages/sdk/schemas/extensions/migration.ts

@@ -1,15 +1,13 @@
 import { z } from "zod";
-import { url } from "../common.ts";
-import { EntitySchema } from "../entity.ts";
+import { ReferenceSchema, TransientEntitySchema } from "../entity.ts";
 
-export const MigrationSchema = EntitySchema.extend({
+export const MigrationSchema = TransientEntitySchema.extend({
     type: z.literal("pub.versia:migration/Migration"),
-    uri: z.null().optional(),
-    author: url,
-    destination: url,
+    author: ReferenceSchema,
+    destination: ReferenceSchema,
 });
 
 export const MigrationExtensionSchema = z.strictObject({
-    previous: url,
-    new: url.nullish(),
+    previous: ReferenceSchema,
+    new: ReferenceSchema.nullish(),
 });

packages/sdk/schemas/extensions/polls.ts

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { isISOString } from "../../regex.ts";
-import { u64, url } from "../common.ts";
+import { u64 } from "../common.ts";
 import { TextContentFormatSchema } from "../contentformat.ts";
-import { EntitySchema } from "../entity.ts";
+import { EntitySchema, ReferenceSchema } from "../entity.ts";
 
 export const VoteSchema = EntitySchema.extend({
     type: z.literal("pub.versia:polls/Vote"),
-    author: url,
-    poll: url,
+    author: ReferenceSchema,
+    poll: ReferenceSchema,
     option: u64,
 });
 
@@ -17,6 +17,6 @@ export const PollExtensionSchema = z.strictObject({
     multiple_choice: z.boolean(),
     expires_at: z
         .string()
-        .refine((v) => isISOString(v), "must be a valid ISO8601 datetime")
+        .refine((v) => isISOString(v), "must be a valid RFC 3339 datetime")
         .nullish(),
 });

packages/sdk/schemas/extensions/reactions.ts

@@ -1,10 +1,9 @@
 import { z } from "zod";
-import { url } from "../common.ts";
-import { EntitySchema } from "../entity.ts";
+import { EntitySchema, ReferenceSchema } from "../entity.ts";
 
 export const ReactionSchema = EntitySchema.extend({
     type: z.literal("pub.versia:reactions/Reaction"),
-    author: url,
-    object: url,
+    author: ReferenceSchema,
+    object: ReferenceSchema,
     content: z.string().min(1).max(256),
 });

packages/sdk/schemas/extensions/reports.ts

@@ -1,12 +1,10 @@
 import { z } from "zod";
-import { url } from "../common.ts";
-import { EntitySchema } from "../entity.ts";
+import { ReferenceSchema, TransientEntitySchema } from "../entity.ts";
 
-export const ReportSchema = EntitySchema.extend({
+export const ReportSchema = TransientEntitySchema.extend({
     type: z.literal("pub.versia:reports/Report"),
-    uri: z.null().optional(),
-    author: url.nullish(),
-    reported: z.array(url),
+    author: ReferenceSchema.nullish(),
+    reported: z.array(ReferenceSchema),
     tags: z.array(z.string()),
     comment: z
         .string()

packages/sdk/schemas/extensions/share.ts

@@ -1,9 +1,8 @@
 import { z } from "zod";
-import { url } from "../common.ts";
-import { EntitySchema } from "../entity.ts";
+import { EntitySchema, ReferenceSchema } from "../entity.ts";
 
 export const ShareSchema = EntitySchema.extend({
     type: z.literal("pub.versia:share/Share"),
-    author: url,
-    shared: url,
+    author: ReferenceSchema,
+    shared: ReferenceSchema,
 });

packages/sdk/schemas/extensions/vanity.ts

@@ -7,11 +7,11 @@
 
 import { z } from "zod";
 import { ianaTimezoneRegex, isISOString } from "../../regex.ts";
-import { url } from "../common.ts";
 import {
     AudioContentFormatSchema,
     ImageContentFormatSchema,
 } from "../contentformat.ts";
+import { ReferenceSchema } from "../entity.ts";
 
 export const VanityExtensionSchema = z.strictObject({
     avatar_overlays: z.array(ImageContentFormatSchema).nullish(),
@@ -21,24 +21,21 @@ export const VanityExtensionSchema = z.strictObject({
     pronouns: z.record(
         z.string(),
         z.array(
-            z.union([
-                z.strictObject({
-                    subject: z.string(),
-                    object: z.string(),
-                    dependent_possessive: z.string(),
-                    independent_possessive: z.string(),
-                    reflexive: z.string(),
-                }),
-                z.string(),
-            ]),
+            z.strictObject({
+                subject: z.string(),
+                object: z.string(),
+                dependent_possessive: z.string(),
+                independent_possessive: z.string(),
+                reflexive: z.string(),
+            }),
         ),
     ),
     birthday: z
         .string()
-        .refine((v) => isISOString(v), "must be a valid ISO8601 datetime")
+        .refine((v) => isISOString(v), "must be a valid RFC 3339 datetime")
         .nullish(),
     location: z.string().nullish(),
-    aliases: z.array(url).nullish(),
+    aliases: z.array(ReferenceSchema).nullish(),
     timezone: z
         .string()
         .regex(ianaTimezoneRegex, "must be a valid IANA timezone")

packages/sdk/schemas/follow.ts

@@ -1,31 +1,26 @@
 import { z } from "zod";
-import { url } from "./common.ts";
-import { EntitySchema } from "./entity.ts";
+import { ReferenceSchema, TransientEntitySchema } from "./entity.ts";
 
-export const FollowSchema = EntitySchema.extend({
+export const FollowSchema = TransientEntitySchema.extend({
     type: z.literal("Follow"),
-    uri: z.null().optional(),
-    author: url,
-    followee: url,
+    author: ReferenceSchema,
+    followee: ReferenceSchema,
 });
 
-export const FollowAcceptSchema = EntitySchema.extend({
+export const FollowAcceptSchema = TransientEntitySchema.extend({
     type: z.literal("FollowAccept"),
-    uri: z.null().optional(),
-    author: url,
-    follower: url,
+    author: ReferenceSchema,
+    follower: ReferenceSchema,
 });
 
-export const FollowRejectSchema = EntitySchema.extend({
+export const FollowRejectSchema = TransientEntitySchema.extend({
     type: z.literal("FollowReject"),
-    uri: z.null().optional(),
-    author: url,
-    follower: url,
+    author: ReferenceSchema,
+    follower: ReferenceSchema,
 });
 
-export const UnfollowSchema = EntitySchema.extend({
+export const UnfollowSchema = TransientEntitySchema.extend({
     type: z.literal("Unfollow"),
-    uri: z.null().optional(),
-    author: url,
-    followee: url,
+    author: ReferenceSchema,
+    followee: ReferenceSchema,
 });

packages/sdk/schemas/index.ts

@@ -8,7 +8,11 @@ export {
     VideoContentFormatSchema,
 } from "./contentformat.ts";
 export { DeleteSchema } from "./delete.ts";
-export { EntitySchema } from "./entity.ts";
+export {
+    EntitySchema,
+    ReferenceSchema,
+    TransientEntitySchema,
+} from "./entity.ts";
 export { DislikeSchema, LikeSchema } from "./extensions/likes.ts";
 export { VoteSchema } from "./extensions/polls.ts";
 export { ReactionSchema } from "./extensions/reactions.ts";

packages/sdk/schemas/instance.ts

@@ -1,13 +1,10 @@
 import { z } from "zod";
 import { extensionRegex, semverRegex } from "../regex.ts";
-import { url } from "./common.ts";
 import { ImageContentFormatSchema } from "./contentformat.ts";
-import { EntitySchema } from "./entity.ts";
+import { TransientEntitySchema } from "./entity.ts";
 
-export const InstanceMetadataSchema = EntitySchema.extend({
+export const InstanceMetadataSchema = TransientEntitySchema.extend({
     type: z.literal("InstanceMetadata"),
-    id: z.null().optional(),
-    uri: z.null().optional(),
     name: z.string().min(1),
     software: z.strictObject({
         name: z.string().min(1),
@@ -28,14 +25,11 @@ export const InstanceMetadataSchema = EntitySchema.extend({
         ),
     }),
     description: z.string().nullish(),
-    host: z.string(),
-    shared_inbox: url.nullish(),
+    domain: z.string(),
     public_key: z.strictObject({
         key: z.string().min(1),
         algorithm: z.literal("ed25519"),
     }),
-    moderators: url.nullish(),
-    admins: url.nullish(),
     logo: ImageContentFormatSchema.nullish(),
     banner: ImageContentFormatSchema.nullish(),
 });

packages/sdk/schemas/note.ts

@@ -4,13 +4,13 @@ import {
     NonTextContentFormatSchema,
     TextContentFormatSchema,
 } from "./contentformat.ts";
-import { EntitySchema } from "./entity.ts";
+import { EntitySchema, ReferenceSchema } from "./entity.ts";
 import { PollExtensionSchema } from "./extensions/polls.ts";
 
 export const NoteSchema = EntitySchema.extend({
     type: z.literal("Note"),
-    attachments: z.array(NonTextContentFormatSchema).nullish(),
-    author: url,
+    attachments: z.array(NonTextContentFormatSchema),
+    author: ReferenceSchema,
     category: z
         .enum([
             "microblog",
@@ -23,16 +23,6 @@ export const NoteSchema = EntitySchema.extend({
         ])
         .nullish(),
     content: TextContentFormatSchema.nullish(),
-    collections: z
-        .strictObject({
-            replies: url,
-            quotes: url,
-            "pub.versia:reactions/Reactions": url.nullish(),
-            "pub.versia:share/Shares": url.nullish(),
-            "pub.versia:likes/Likes": url.nullish(),
-            "pub.versia:likes/Dislikes": url.nullish(),
-        })
-        .catchall(url),
     device: z
         .strictObject({
             name: z.string(),
@@ -40,22 +30,20 @@ export const NoteSchema = EntitySchema.extend({
             url: url.nullish(),
         })
         .nullish(),
-    group: url.or(z.enum(["public", "followers"])).nullish(),
-    is_sensitive: z.boolean().nullish(),
-    mentions: z.array(url).nullish(),
-    previews: z
-        .array(
-            z.strictObject({
-                link: url,
-                title: z.string(),
-                description: z.string().nullish(),
-                image: url.nullish(),
-                icon: url.nullish(),
-            }),
-        )
-        .nullish(),
-    quotes: url.nullish(),
-    replies_to: url.nullish(),
+    group: ReferenceSchema.or(z.enum(["public", "followers"])).nullish(),
+    is_sensitive: z.boolean(),
+    mentions: z.array(ReferenceSchema),
+    previews: z.array(
+        z.strictObject({
+            link: url,
+            title: z.string(),
+            description: z.string().nullish(),
+            image: url.nullish(),
+            icon: url.nullish(),
+        }),
+    ),
+    quotes: ReferenceSchema.nullish(),
+    replies_to: ReferenceSchema.nullish(),
     subject: z.string().nullish(),
     extensions: EntitySchema.shape.extensions
         .unwrap()

packages/sdk/schemas/user.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { url } from "./common.ts";
 import {
     ImageContentFormatSchema,
     TextContentFormatSchema,
@@ -8,25 +7,17 @@ import { EntitySchema } from "./entity.ts";
 import { MigrationExtensionSchema } from "./extensions/migration.ts";
 import { VanityExtensionSchema } from "./extensions/vanity.ts";
 
-export const PublicKeyDataSchema = z.strictObject({
-    key: z.string().min(1),
-    actor: url,
-    algorithm: z.literal("ed25519"),
-});
-
 export const UserSchema = EntitySchema.extend({
     type: z.literal("User"),
     avatar: ImageContentFormatSchema.nullish(),
     bio: TextContentFormatSchema.nullish(),
     display_name: z.string().nullish(),
-    fields: z
-        .array(
-            z.strictObject({
-                key: TextContentFormatSchema,
-                value: TextContentFormatSchema,
-            }),
-        )
-        .nullish(),
+    fields: z.array(
+        z.strictObject({
+            key: TextContentFormatSchema,
+            value: TextContentFormatSchema,
+        }),
+    ),
     username: z
         .string()
         .min(1)
@@ -35,20 +26,8 @@ export const UserSchema = EntitySchema.extend({
             "must be alphanumeric, and may contain _ or -",
         ),
     header: ImageContentFormatSchema.nullish(),
-    public_key: PublicKeyDataSchema,
-    manually_approves_followers: z.boolean().nullish(),
-    indexable: z.boolean().nullish(),
-    inbox: url,
-    collections: z
-        .object({
-            featured: url,
-            followers: url,
-            following: url,
-            outbox: url,
-            "pub.versia:likes/Likes": url.nullish(),
-            "pub.versia:likes/Dislikes": url.nullish(),
-        })
-        .catchall(url),
+    manually_approves_followers: z.boolean(),
+    indexable: z.boolean(),
     extensions: EntitySchema.shape.extensions
         .unwrap()
         .unwrap()