Reorg

Author: Wes Biggs

README.md

@@ -1,6 +1,6 @@
 # Official DSNP Schemas
 
-**Matching DSNP Version: v1.2.0**
+**Matching DSNP Version: pre-v1.3.0**
 
 ## Use Schemas as Library
 
@@ -9,12 +9,38 @@
 npm install @dsnp/schemas
 ```
 
-### Use Schema
+
+### Get Announcement Type or User Data Type Metadata
 
 ```typescript
-import { dsnp } from "@dsnp/schemas";
+import {
+  AnnouncementType,
+  descriptorForAnnouncementType,
+  UserDataType,
+  descriptorForUserDataType
+} from "@dsnp/schemas";
+
+const broadcastSchema = descriptorForAnnouncementType(AnnouncementType.Broadcast);
+console.log(broadcastSchema);
+/*
+{
+  announcementType: 2,
+  parquetSchema: [ ... ],
+  tombstoneAllowed: true
+}
+*/
 
-console.log(dsnp.broadcast);
+
+const publicFollowsSchema = descriptorForUserDataType(UserDataType.PublicFollows);
+console.log(publicFollowsSchema);
+/*
+{
+  systemName: 'publicFollows',
+  encryptionAlgorithm: null,
+  compressionCodec: 'DEFLATE',
+  avroSchema: { ... }
+}
+*/
 ```
 
 ### Write Parquet files
@@ -24,14 +50,14 @@ npm install @dsnp/parquetjs
 ```
 
 ```typescript
-import { Announcement } from "@dsnp/schemas"; 
+import { AnnouncementType } from "@dsnp/schemas"; 
 import { parquet } from "@dsnp/schemas";
 import { ParquetWriter } from "@dsnp/parquetjs";
 
-const [parquetSchema, writerOptions] = parquet.fromDSNPSchema(Announcement["broadcast"].parquetSchema);
+const [parquetSchema, writerOptions] = parquet.fromDSNPSchema(descriptorForAnnouncementType(AnnouncementType.Broadcast).parquetSchema);
 const writer = await ParquetWriter.openFile(parquetSchema, "./file.parquet", writerOptions);
 writer.appendRow({
-  announcementType: 2,
+  announcementType: AnnouncementType.Broadcast,
   contentHash: "0x1234567890abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
   fromId: 78187493520,
   url: "https://spec.dsnp.org/DSNP/Types/Broadcast.html",
@@ -42,11 +68,10 @@ await writer.close();
 ### Write Avro objects
 
 ```typescript
-import { UserData } from "@dsnp/schemas";
+import { UserDataType, descriptorForUserDataType } from "@dsnp/schemas";
 import avro from "avsc";
 
-const publicKeyAvroSchema = avro.Type.forSchema(UserData["keyAgreementPublicKeys"].avroSchema);
-const publicKeyMulticodec = Buffer.from([0xec, 0x01, 0x00, ...]);
+const publicKeyAvroSchema = avro.Type.forSchema(descriptorForUserDataType(UserDataType.KeyAgreementPublicKeys).avroSchema);
+const publicKeyMulticodec = Buffer.from("ec01000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", "hex");
 const avroBuffer = publicKeyAvroSchema.toBuffer({ publicKey: publicKeyMulticodec });
 ```
-

announcements.spec.ts

@@ -0,0 +1,11 @@
+import { AnnouncementType, descriptorForAnnouncementType } from "./announcements.js";
+
+describe("Announcements API", () => {
+  it("has numeric AnnouncementType values", () => {
+    expect(AnnouncementType.Broadcast).toStrictEqual(2);
+  });
+
+  it("allows lookup by enum", () => {
+    expect(descriptorForAnnouncementType(AnnouncementType.Broadcast).announcementType).toStrictEqual(2);
+  });
+});

announcements.ts

@@ -0,0 +1,57 @@
+import broadcast from "./parquet/broadcast.json";
+import reaction from "./parquet/reaction.json";
+import reply from "./parquet/reply.json";
+import tombstone from "./parquet/tombstone.json";
+import update from "./parquet/update.json";
+
+import { DSNPParquetSchema } from "./types/dsnp-parquet.js";
+
+export enum AnnouncementType {
+  Tombstone = 0,
+  Broadcast = 2,
+  Reply = 3,
+  Reaction = 4,
+  Update = 6,
+}
+
+export type AnnouncementDescriptor = {
+  announcementType: AnnouncementType;
+  parquetSchema: DSNPParquetSchema;
+  tombstoneAllowed: boolean;
+};
+
+export function descriptorForAnnouncementType(announcementType: AnnouncementType): AnnouncementDescriptor {
+  switch (announcementType) {
+    case AnnouncementType.Tombstone:
+      return {
+        announcementType: AnnouncementType.Tombstone,
+        parquetSchema: tombstone as DSNPParquetSchema,
+        tombstoneAllowed: false,
+      };
+    case AnnouncementType.Broadcast:
+      return {
+        announcementType: AnnouncementType.Broadcast,
+        parquetSchema: broadcast as DSNPParquetSchema,
+        tombstoneAllowed: true,
+      };
+    case AnnouncementType.Reply:
+      return {
+        announcementType: AnnouncementType.Reply,
+        parquetSchema: reply as DSNPParquetSchema,
+        tombstoneAllowed: true,
+      };
+    case AnnouncementType.Reaction:
+      return {
+        announcementType: AnnouncementType.Reaction,
+        parquetSchema: reaction as DSNPParquetSchema,
+        tombstoneAllowed: false,
+      };
+    case AnnouncementType.Update:
+      return {
+        announcementType: AnnouncementType.Update,
+        parquetSchema: update as DSNPParquetSchema,
+        tombstoneAllowed: false,
+      };
+  }
+  throw new Error("Invalid enum value");
+}

avro/GraphEdge.json

@@ -0,0 +1,18 @@
+{
+  "namespace": "org.dsnp",
+  "name": "GraphEdge",
+  "type": "record",
+  "doc": "A relationship to another DSNP user",
+  "fields": [
+    {
+      "name": "userId",
+      "type": "long",
+      "doc": "The other user's DSNP User Id"
+    },
+    {
+      "name": "since",
+      "type": "long",
+      "doc": "Timestamp in Unix epoch seconds when this relationship was originally established"
+    }
+  ]
+}

avro/GraphEdge.spec.ts

@@ -1,14 +1,14 @@
-import graphEdgeSchema from "./GraphEdge.js";
-import avro from "avsc";
+import graphEdgeSchema from "./GraphEdge.json";
+import { Type, Schema } from "avsc";
 
 describe("Graph Edge Schema", () => {
   it("Is Avro", () => {
-    const parsed = avro.Type.forSchema(graphEdgeSchema);
+    const parsed = Type.forSchema(graphEdgeSchema as Schema);
     expect(parsed).toBeDefined();
   });
 
   it("Encodes and decodes object", () => {
-    const parsed = avro.Type.forSchema(graphEdgeSchema);
+    const parsed = Type.forSchema(graphEdgeSchema as Schema);
     const encoded = parsed.toBuffer({ userId: 123456789, since: 1722524715 });
     const decoded = parsed.fromBuffer(encoded);
     expect(decoded.userId).toStrictEqual(123456789);

avro/GraphEdge.ts

@@ -0,0 +1,7 @@
+{
+  "namespace": "org.dsnp",
+  "name": "PRId",
+  "type": "fixed",
+  "size": 8,
+  "doc": "Pseudonymous Relationship Identifier"
+}

avro/PRId.json

@@ -1,14 +1,14 @@
-import pridSchema from "./PRId.js";
-import avro from "avsc";
+import pridSchema from "./PRId.json";
+import { Type, Schema } from "avsc";
 
 describe("PRId Schema", () => {
   it("Is Avro", () => {
-    const parsed = avro.Type.forSchema(pridSchema);
+    const parsed = Type.forSchema(pridSchema as Schema);
     expect(parsed).toBeDefined();
   });
 
   it("Encodes and decodes buffer", () => {
-    const parsed = avro.Type.forSchema(pridSchema);
+    const parsed = Type.forSchema(pridSchema as Schema);
     const someBytes = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7]);
     const encoded = parsed.toBuffer(someBytes);
     const decoded = parsed.fromBuffer(encoded);

avro/PRId.spec.ts

@@ -0,0 +1,18 @@
+{
+  "namespace": "org.dsnp",
+  "name": "ProfileResource",
+  "type": "record",
+  "doc": "A relationship to another DSNP user",
+  "fields": [
+    {
+      "name": "type",
+      "type": "int",
+      "doc": "Type of resource"
+    },
+    {
+      "name": "contentAddress",
+      "type": "string",
+      "doc": "Content address for the resource"
+    }
+  ]
+}

avro/PRId.ts

@@ -0,0 +1,21 @@
+import profileResourceSchema from "./ProfileResource.json";
+import { Type, Schema } from "avsc";
+
+describe("Profile Resource Schema", () => {
+  it("Is Avro", () => {
+    const parsed = Type.forSchema(profileResourceSchema as Schema);
+    expect(parsed).toBeDefined();
+  });
+
+  it("Encodes and decodes object", () => {
+    const parsed = Type.forSchema(profileResourceSchema as Schema);
+    const exampleCid = "bafybeida7z24mig7j3oagjru7s2gw6xbfkh7fryvah6ho2ar77xb7aleom";
+    const encoded = parsed.toBuffer({
+      type: 1,
+      contentAddress: exampleCid,
+    });
+    const decoded = parsed.fromBuffer(encoded);
+    expect(decoded.type).toStrictEqual(1);
+    expect(decoded.contentAddress).toStrictEqual(exampleCid);
+  });
+});

avro/ProfileResource.json

@@ -0,0 +1,12 @@
+{
+  "type": "record",
+  "name": "PublicKey",
+  "namespace": "org.dsnp",
+  "fields": [
+    {
+      "name": "publicKey",
+      "doc": "Multicodec public key",
+      "type": "bytes"
+    }
+  ]
+}

avro/ProfileResource.spec.ts

@@ -1,14 +1,14 @@
-import publicKeySchema from "./PublicKey.js";
-import avro from "avsc";
+import publicKeySchema from "./PublicKey.json";
+import { Type, Schema } from "avsc";
 
 describe("Public Key Schema", () => {
   it("Is Avro", () => {
-    const parsed = avro.Type.forSchema(publicKeySchema);
+    const parsed = Type.forSchema(publicKeySchema as Schema);
     expect(parsed).toBeDefined();
   });
 
   it("Encodes and decodes object", () => {
-    const parsed = avro.Type.forSchema(publicKeySchema);
+    const parsed = Type.forSchema(publicKeySchema as Schema);
     const someBytes = Buffer.from([0, 1, 2, 3]);
     const encoded = parsed.toBuffer({ publicKey: someBytes });
     const decoded = parsed.fromBuffer(encoded);