@audius/sdk 0.0.0

package/src/services/schemaValidator/SchemaValidator.ts

@@ -0,0 +1,105 @@
+import { validate } from 'jsonschema'
+
+import TrackSchema from './schemas/trackSchema.json'
+import UserSchema from './schemas/userSchema.json'
+
+export const trackSchemaType = 'TrackSchema'
+export const userSchemaType = 'UserSchema'
+
+type SchemaConfig = {
+  schema: {
+    definitions: Record<
+      string,
+      | { required: string[]; properties: Record<string, { default: unknown }> }
+      | {}
+    >
+  }
+  baseDefinition: string
+  validate?: (obj: Record<string, unknown>) => void
+}
+
+type SchemaType = typeof trackSchemaType | typeof userSchemaType
+
+export type Schemas = {
+  TrackSchema: SchemaConfig
+  UserSchema: SchemaConfig
+}
+
+export class SchemaValidator {
+  schemas: Schemas | undefined
+
+  init() {
+    /**
+     * Fully formed schemas object looks like the below
+     * {
+     *   'TrackSchema': {
+     *     schema: <schemaJSON>,
+     *     baseDefinition: 'String', //name of base definition property in schema
+     *     validate: function // returns error if not validated correctly, otherwise null
+     *   },
+     *   'UserSchema': ...
+     * }
+     *
+     * validate works like this `this.UserSchema.validate(userObj)`
+     */
+    this.schemas = {
+      [trackSchemaType]: {
+        schema: TrackSchema,
+        baseDefinition: 'Track'
+      },
+      [userSchemaType]: {
+        schema: UserSchema,
+        baseDefinition: 'User'
+      }
+    }
+
+    for (const schemaType in this.schemas) {
+      const typedSchemaType = schemaType as SchemaType
+      this.schemas[typedSchemaType].validate = (
+        obj: Record<string, unknown>
+      ) => {
+        this.addMissingFields(obj, typedSchemaType)
+
+        const result = validate(obj, this.schemas?.[typedSchemaType].schema)
+        if (result.errors.length > 0)
+          throw new Error(
+            `${schemaType} validation failed with errors: ${JSON.stringify(
+              result.errors
+            )}`
+          )
+      }
+    }
+  }
+
+  getSchemas() {
+    return this.schemas
+  }
+
+  addMissingFields(obj: Record<string, unknown>, schemaType: SchemaType) {
+    if (!this.schemas) {
+      return
+    }
+    // schema is the entire imporoted schema, including all the definitions for JSON fields
+    const { schema, baseDefinition } = this.schemas[schemaType]
+    // schemaTypeObj is only the subset of the schema with only one definition for main schema type
+    const schemaTypeObj = schema.definitions[baseDefinition]
+    // iterate through every required property, ensuring it exists or setting a default value
+    if (schemaTypeObj && 'required' in schemaTypeObj) {
+      schemaTypeObj.required.forEach((req) => {
+        if (!Object.prototype.hasOwnProperty.call(obj, req)) {
+          if (
+            Object.prototype.hasOwnProperty.call(
+              schemaTypeObj.properties[req],
+              'default'
+            )
+          ) {
+            obj[req] = schemaTypeObj.properties[req]?.default
+          } else
+            throw new Error(
+              `Could not set default value for missing field ${req}`
+            )
+        }
+      })
+    }
+  }
+}

package/src/services/schemaValidator/index.ts

@@ -0,0 +1 @@
+export * from './SchemaValidator'

package/src/services/schemaValidator/schemas/trackSchema.json

@@ -0,0 +1,267 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$ref": "#/definitions/Track",
+    "definitions": {
+        "Track": {
+            "type": "object",
+            "additionalProperties": true,
+            "$comment": "Additional properties enabled because the data return by discovery providers may contain other properties like blockhash, is_current, which are not strictly part of the metadata.",
+            "properties": {
+                "title": {
+                    "type": "string",
+                    "default": null
+                },
+                "length": {
+                    "type": ["integer", "null"],
+                    "default": null
+                },
+                "cover_art": {
+                    "type": ["string", "null"],
+                    "default": null,
+                    "$ref": "#/definitions/CID"
+                },
+                "cover_art_sizes": {
+                  "$comment": "type can be null if attached as a stem",
+                  "type": ["string",  "null"],
+                  "default": null,
+                  "$ref": "#/definitions/CID"
+              },
+                "tags": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "genre": {
+                    "$comment": "genre can be null if attached as a stem",
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "mood": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "credits_splits": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "create_date": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "release_date": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "file_type": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "description": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "license": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "isrc": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "iswc": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "track_segments": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "$ref": "#/definitions/TrackSegment"
+                    },
+                    "default": [],
+                    "$comment": "default set to empty array to unblock stalling indexing. if set to null, discprov db will reject because of not-NULL constraint"
+                },
+                "is_unlisted": {
+                    "type": "boolean",
+                    "default": false
+                },
+                "field_visibility": {
+                    "type": "object",
+                    "$ref": "#/definitions/FieldVisibility",
+                    "default": {
+                        "mood": true,
+                        "tags": true,
+                        "genre": true,
+                        "share": true,
+                        "play_count": true,
+                        "remixes": true
+                    }
+                },
+                "download": {
+                    "type": ["object", "null"],
+                    "$ref": "#/definitions/Download",
+                    "default": {
+                        "cid": null,
+                        "is_downloadable": false,
+                        "requires_follow": false
+                    }
+                },
+                "stem_of": {
+                    "type": ["object", "null"],
+                    "$ref": "#/definitions/StemOf",
+                    "default": null
+                },
+                "remix_of": {
+                    "type": ["object", "null"],
+                    "$ref": "#/definitions/RemixOf",
+                    "default": null
+                }
+            },
+            "required": [
+                "cover_art",
+                "cover_art_sizes",
+                "create_date",
+                "credits_splits",
+                "description",
+                "download",
+                "field_visibility",
+                "file_type",
+                "genre",
+                "is_unlisted",
+                "isrc",
+                "iswc",
+                "length",
+                "license",
+                "mood",
+                "release_date",
+                "remix_of",
+                "stem_of",
+                "tags",
+                "title",
+                "track_segments"
+            ],
+            "title": "Track"
+        },
+        "RemixOf": {
+            "type": ["object", "null"],
+            "additionalProperties": false,
+            "properties": {
+                "tracks": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "$ref": "#/definitions/TrackElement"
+                    }
+                }
+            },
+            "required": [
+                "tracks"
+            ],
+            "title": "RemixOf"
+        },
+        "TrackElement": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "parent_track_id": {
+                    "type": "integer"
+                }
+            },
+            "required": [
+                "parent_track_id"
+            ],
+            "title": "TrackElement"
+        },
+        "Download": {
+            "type": ["object", "null"],
+            "additionalProperties": false,
+            "properties": {
+                "cid": {
+                    "type": ["string", "null"],
+                    "$ref": "#/definitions/CID"
+                },
+                "is_downloadable": {
+                    "type": "boolean"
+                },
+                "requires_follow": {
+                    "type": "boolean"
+                }
+            },
+            "required": [
+                "cid",
+                "is_downloadable",
+                "requires_follow"
+            ],
+            "title": "Download"
+        },
+        "FieldVisibility": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "mood": {
+                    "type": "boolean"
+                },
+                "tags": {
+                    "type": "boolean"
+                },
+                "genre": {
+                    "type": "boolean"
+                },
+                "share": {
+                    "type": "boolean"
+                },
+                "play_count": {
+                    "type": "boolean"
+                },
+                "remixes": {
+                    "type": "boolean"
+                }
+            },
+            "required": [
+            ],
+            "$comment": "No required fields for FieldVisibility because it causes backwards compatibility issues. If we added a new property, we don't want old records to fail if all properties are not specified(and overwrite the values with the defaults), but we also don't want to set new properties especially on the discovery provider because then we'd be writing properties not present in the metadata written on chain.",
+            "title": "FieldVisibility"
+        },
+        "StemOf": {
+            "type": ["object", "null"],
+            "additionalProperties": false,
+            "properties": {
+                "category": {
+                    "type": "string"
+                },
+                "parent_track_id": {
+                    "type": "integer"
+                }
+            },
+            "required": [
+                "category",
+                "parent_track_id"
+            ],
+            "title": "StemOf"
+        },
+        "TrackSegment": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "duration": {
+                    "type": "number"
+                },
+                "multihash": {
+                    "type": "string",
+                    "$ref": "#/definitions/CID"
+                }
+            },
+            "required": [
+                "duration",
+                "multihash"
+            ],
+            "title": "TrackSegment"
+        },
+        "CID": {
+            "type": ["string", "null"],
+            "minLength": 46,
+            "maxLength": 46,
+            "pattern": "^Qm[a-zA-Z0-9]{44}$",
+            "title": "CID"
+        }
+    }
+}

package/src/services/schemaValidator/schemas/userSchema.json

@@ -0,0 +1,230 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$ref": "#/definitions/User",
+    "definitions": {
+        "User": {
+            "type": "object",
+            "additionalProperties": true,
+            "properties": {
+                "name": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "profile_picture": {
+                    "type": ["string", "null"],
+                    "default": null,
+                    "$ref": "#/definitions/CID"
+                },
+                "profile_picture_sizes": {
+                    "type": ["string", "null"],
+                    "default": null,
+                    "$ref": "#/definitions/CID"
+                },
+                "cover_photo": {
+                    "type": ["string", "null"],
+                    "default": null,
+                    "$ref": "#/definitions/CID"
+                },
+                "cover_photo_sizes": {
+                    "type": ["string", "null"],
+                    "default": null,
+                    "$ref": "#/definitions/CID"
+                },
+                "bio": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "location": {
+                    "type": ["string", "null"],
+                    "default": null
+                },
+                "associated_wallets": {
+                    "$ref": "#/definitions/AssociatedWallets"
+                },
+                "associated_sol_wallets": {
+                    "$ref": "#/definitions/AssociatedSOLWallets"
+                },
+                "collectibles": {
+                    "$ref": "#/definitions/Collectibles"
+                },
+                "playlist_library": {
+                    "$ref": "#/definitions/PlaylistLibrary"
+                },
+                "events": {
+                    "$ref": "#/definitions/Events"
+                },
+                "is_deactivated": {
+                    "type": "boolean",
+                    "default": false
+                }
+            },
+            "required": [
+                "bio",
+                "cover_photo",
+                "cover_photo_sizes",
+                "location",
+                "name",
+                "profile_picture",
+                "profile_picture_sizes"
+            ],
+            "title": "User"
+        },
+        "CID": {
+            "type": ["string", "null"],
+            "minLength": 46,
+            "maxLength": 46,
+            "pattern": "^Qm[a-zA-Z0-9]{44}$",
+            "title": "CID"
+        },
+        "AssociatedWallets": {
+            "type": ["object", "null"],
+            "default": null,
+            "patternProperties": {
+                "^0x[a-fA-F0-9]{40}$": { "$ref": "#/definitions/WalletMetadata" }
+            },
+            "additionalProperties": false,
+            "properties": {},
+            "required": [],
+            "$comment": "",
+            "title": "AssociatedWallets"
+        },
+        "AssociatedSOLWallets": {
+            "type": ["object", "null"],
+            "default": null,
+            "patternProperties": {
+                "^[a-zA-Z0-9]{44}$": { "$ref": "#/definitions/WalletMetadata" }
+            },
+            "additionalProperties": false,
+            "properties": {},
+            "required": [],
+            "$comment": "",
+            "title": "AssociatedSOLWallets"
+        },
+        "WalletMetadata": {
+            "type": ["object"],
+            "additionalProperties": true,
+            "properties": {
+                "signature": {
+                    "type": "string"
+                }
+            },
+            "required": ["signature"],
+            "$comment": "",
+            "title": "WalletMetadata"
+        },
+        "Collectible": {
+            "type": "object",
+            "additionalProperties": false
+        },
+        "Collectibles": {
+            "type": ["object", "null"],
+            "default": null,
+            "additionalProperties": {
+                "$ref": "#/definitions/Collectible"
+            },
+            "properties": {
+                "order": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "order"
+            ]
+        },
+        "PlaylistIdentifier": {
+            "properties": {
+                "type": {
+                    "type": "string",
+                    "const": "playlist"
+                },
+                "playlist_id": {
+                    "type": "integer"
+                }
+            }
+
+        },
+        "ExplorePlaylistIdentifier": {
+            "properties": {
+                "type": {
+                    "type": "string",
+                    "const": "explore_playlist"
+                },
+                "playlist_id": {
+                    "type": "string",
+                    "pattern": "^[a-zA-Z \/-?]+$"
+                }
+            }
+        },
+        "PlaylistLibraryIdentifier": {
+            "oneOf": [
+                {
+                    "$ref": "#/definitions/PlaylistIdentifier"
+                },
+                {
+                    "$ref": "#/definitions/ExplorePlaylistIdentifier"
+                }
+            ]
+        },
+        "PlaylistLibraryFolder": {
+            "properties": {
+                "type": {
+                    "type": "string",
+                    "const": "folder"
+                },
+                "id": {
+                    "type": "string"
+                },
+                "name": {
+                    "type": "string"
+                },
+                "contents": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "$ref": "#/definitions/PlaylistLibraryFolder"
+                            },
+                            {
+                                "$ref": "#/definitions/PlaylistLibraryIdentifier"
+                            }
+                        ]
+                    }
+                }
+            }
+        },
+        "PlaylistLibrary": {
+            "type": ["object", "null"],
+            "default": null,
+            "properties": {
+                "contents": {
+                    "type": "array",
+                    "items": {
+                        "oneOf": [
+                            {
+                                "$ref": "#/definitions/PlaylistLibraryFolder"
+                            },
+                            {
+                                "$ref": "#/definitions/PlaylistLibraryIdentifier"
+                            }
+                        ]
+                    }
+                }
+            }
+        },
+        "Events": {
+            "type": ["object", "null"],
+            "default": null,
+            "properties": {
+                "referrer": {
+                    "type": "integer"
+                },
+                "is_mobile_user": {
+                    "type": "boolean"
+                }
+            }
+        }
+    }
+}

package/src/services/solanaAudiusData/errors.ts

@@ -0,0 +1,20 @@
+import { ProgramError } from '@project-serum/anchor'
+import * as AudiusData from '@audius/anchor-audius-data'
+
+/**
+ * All errors returned by Anchor Audius Data
+ */
+
+export const CustomAudiusDataErrors = new Map(
+  AudiusData.idl.errors.map(({ code, msg }) => [code, msg])
+)
+export const audiusDataErrorMapping = {
+  fromErrorCode: (errorCode: number) => {
+    const programError = ProgramError.parse(
+      `"Custom":${errorCode.toString()}}`,
+      CustomAudiusDataErrors
+    )
+    if (programError === null) return 'UNKNOWN'
+    return programError.msg
+  }
+}