Revert from using .json to .ts files for schemas to avoid CJS/ESM incompatibility with import assertions.

Author: Wes Biggs

announcements.ts

@@ -1,8 +1,8 @@
-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 broadcast from "./parquet/broadcast.js";
+import reaction from "./parquet/reaction.js";
+import reply from "./parquet/reply.js";
+import tombstone from "./parquet/tombstone.js";
+import update from "./parquet/update.js";
 
 import { DSNPParquetSchema } from "./types/dsnp-parquet.js";
 
@@ -25,31 +25,31 @@ export function descriptorForAnnouncementType(announcementType: AnnouncementType
     case AnnouncementType.Tombstone:
       return {
         announcementType: AnnouncementType.Tombstone,
-        parquetSchema: tombstone as DSNPParquetSchema,
+        parquetSchema: tombstone,
         tombstoneAllowed: false,
       };
     case AnnouncementType.Broadcast:
       return {
         announcementType: AnnouncementType.Broadcast,
-        parquetSchema: broadcast as DSNPParquetSchema,
+        parquetSchema: broadcast,
         tombstoneAllowed: true,
       };
     case AnnouncementType.Reply:
       return {
         announcementType: AnnouncementType.Reply,
-        parquetSchema: reply as DSNPParquetSchema,
+        parquetSchema: reply,
         tombstoneAllowed: true,
       };
     case AnnouncementType.Reaction:
       return {
         announcementType: AnnouncementType.Reaction,
-        parquetSchema: reaction as DSNPParquetSchema,
+        parquetSchema: reaction,
         tombstoneAllowed: false,
       };
     case AnnouncementType.Update:
       return {
         announcementType: AnnouncementType.Update,
-        parquetSchema: update as DSNPParquetSchema,
+        parquetSchema: update,
         tombstoneAllowed: false,
       };
   }

avro/GraphEdge.json

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

avro/GraphEdge.spec.ts

@@ -0,0 +1,22 @@
+import { Schema } from "avsc";
+
+const GraphEdge: Schema = {
+  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",
+    },
+  ],
+};
+
+export default GraphEdge;

avro/GraphEdge.ts

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

avro/PRId.json

@@ -0,0 +1,11 @@
+import { Schema } from "avsc";
+
+const PRId: Schema = {
+  namespace: "org.dsnp",
+  name: "PRId",
+  type: "fixed",
+  size: 8,
+  doc: "Pseudonymous Relationship Identifier",
+};
+
+export default PRId;

avro/PRId.spec.ts

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

avro/PRId.ts

@@ -1,4 +1,6 @@
-{
+import { Schema } from "avsc";
+
+const ProfileResource: Schema = {
   "namespace": "org.dsnp",
   "name": "ProfileResource",
   "type": "record",
@@ -15,4 +17,7 @@
       "doc": "Content address for the resource"
     }
   ]
-}
+};
+
+export default ProfileResource;
+

avro/ProfileResource.spec.ts

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

avro/ProfileResource.json renamed to avro/ProfileResource.ts

@@ -0,0 +1,23 @@
+import { Schema } from "avsc";
+
+const PublicKey: Schema = {
+  type: "record",
+  name: "PublicKey",
+  namespace: "org.dsnp",
+  fields: [
+    // When converting from Frequency Data to DSNP Announcement, assume:
+    // - announcementType = 7
+    // - fromId = [Associated MSA Id]
+    // - keyType = 1 for keyAgreement (used for graph encryption/decryption and PRIds), or
+    //   keyType = 2 for assertionMethod (used for credential signatures)
+    // - keyId = `index` from the Itemized storage
+    // DID Key Id could be publicKey or could be the index of the array. Not user assigned
+    {
+      name: "publicKey",
+      doc: "Multicodec public key",
+      type: "bytes",
+    },
+  ],
+};
+
+export default PublicKey;

avro/PublicKey.json

@@ -1,12 +1,11 @@
 import { testCompression, testParquetSchema } from "../test/parquet.js";
 import * as generators from "@dsnp/test-generators";
-import broadcastSchema from "./broadcast.json";
-import { DSNPParquetSchema } from "../types/dsnp-parquet.js";
+import broadcastSchema from "./broadcast.js";
 
 describe("Broadcast Spec", () => {
-  testParquetSchema(broadcastSchema as DSNPParquetSchema);
+  testParquetSchema(broadcastSchema);
 
-  testCompression("broadcast", broadcastSchema as DSNPParquetSchema, () => ({
+  testCompression("broadcast", broadcastSchema, () => ({
     announcementType: 2,
     contentHash: generators.generateHash(),
     fromId: generators.randInt(10000000),

avro/PublicKey.spec.ts

@@ -0,0 +1,40 @@
+import { DSNPParquetSchema } from "../types/dsnp-parquet.js";
+
+const broadcast: DSNPParquetSchema = [
+  {
+    name: "announcementType",
+    column_type: {
+      INTEGER: {
+        bit_width: 32,
+        sign: true,
+      },
+    },
+    compression: "GZIP",
+    bloom_filter: false,
+  },
+  {
+    name: "contentHash",
+    column_type: "BYTE_ARRAY",
+    compression: "GZIP",
+    bloom_filter: true,
+  },
+  {
+    name: "fromId",
+    column_type: {
+      INTEGER: {
+        bit_width: 64,
+        sign: false,
+      },
+    },
+    compression: "GZIP",
+    bloom_filter: true,
+  },
+  {
+    name: "url",
+    column_type: "STRING",
+    compression: "GZIP",
+    bloom_filter: false,
+  },
+];
+
+export default broadcast;