@nina-protocol/nina-db 0.0.92 → 0.0.93

package/dist/models/Release.js

@@ -0,0 +1,282 @@
+import anchor from '@project-serum/anchor';
+import { Metaplex } from '@metaplex-foundation/js';
+import { Model } from 'objection';
+import { stripHtmlIfNeeded, tweetNewRelease } from '../utils/index.js';
+import Account from './Account.js';
+import Exchange from './Exchange.js';
+import Hub from './Hub.js';
+import Post from './Post.js';
+import Tag from './Tag.js';
+import axios from 'axios';
+import promiseRetry from 'promise-retry';
+import { customAlphabet } from 'nanoid';
+const alphabet = '0123456789abcdefghijklmnopqrstuvwxyz';
+const randomStringGenerator = customAlphabet(alphabet, 12);
+export default class Release extends Model {
+    static tableName = 'releases';
+    static idColumn = 'id';
+    static jsonSchema = {
+        type: 'object',
+        required: ['publicKey', 'mint', 'metadata', 'datetime', 'slug', 'price'],
+        properties: {
+            publicKey: { type: 'string' },
+            mint: { type: 'string' },
+            slug: { type: 'string' },
+            metadata: {
+                type: 'object',
+                required: ['name', 'symbol', 'description', 'image', 'properties',],
+                properties: {
+                    name: { type: 'string' },
+                    symbol: { type: 'string' },
+                    description: { type: 'string' },
+                    properties: {
+                        type: 'object',
+                        properties: {
+                            artist: { type: 'string' },
+                            title: { type: 'string' },
+                            date: { type: 'string' },
+                            files: { type: 'array' },
+                            category: { type: 'string' },
+                            creators: { type: 'array' },
+                        }
+                    }
+                }
+            },
+            price: { type: 'string' },
+            archived: { type: 'boolean' },
+        },
+    };
+    static findOrCreate = async (publicKey, hubPublicKey = null) => {
+        try {
+            let release = await Release.query().findOne({ publicKey });
+            if (release) {
+                return release;
+            }
+            const connection = new anchor.web3.Connection(process.env.SOLANA_CLUSTER_URL);
+            const provider = new anchor.AnchorProvider(connection, {}, { commitment: 'confirmed' });
+            const program = await anchor.Program.at(process.env.NINA_PROGRAM_ID, provider);
+            const metaplex = new Metaplex(connection);
+            let attempts = 0;
+            const releaseAccount = await promiseRetry(async (retry) => {
+                try {
+                    attempts += 1;
+                    const result = await program.account.release.fetch(new anchor.web3.PublicKey(publicKey), 'confirmed');
+                    return result;
+                }
+                catch (error) {
+                    console.log('error fetching release account', error);
+                    retry(error);
+                }
+            }, {
+                retries: 50,
+                minTimeout: 500,
+                maxTimeout: 1500,
+            });
+            let metadataAccount = (await metaplex.nfts().findAllByMintList({ mints: [releaseAccount.releaseMint] }, { commitment: 'confirmed' }))[0];
+            if (!metadataAccount) {
+                throw new Error('No metadata account found for release - is not a complete release');
+            }
+            let json;
+            try {
+                json = (await axios.get(metadataAccount.uri.replace('www.', '').replace('arweave.net', 'gateway.irys.xyz'))).data;
+            }
+            catch (error) {
+                json = (await axios.get(metadataAccount.uri.replace('gateway.irys.xyz', 'arweave.net'))).data;
+            }
+            const slug = await this.generateSlug(json);
+            let publisher = await Account.findOrCreate(releaseAccount.authority.toBase58());
+            release = await this.createRelease({
+                publicKey,
+                mint: releaseAccount.releaseMint.toBase58(),
+                metadata: json,
+                datetime: new Date(releaseAccount.releaseDatetime.toNumber() * 1000).toISOString(),
+                slug,
+                publisherId: publisher.id,
+                releaseAccount
+            });
+            if (hubPublicKey) {
+                const hub = await Hub.query().findOne({ publicKey: hubPublicKey });
+                await release.$query().patch({ hubId: hub.id });
+                await Hub.relatedQuery('releases').for(hub.id).patch({
+                    visible: true,
+                }).where({ id: release.id });
+            }
+            return release;
+        }
+        catch (error) {
+            console.log('error finding or creating release: ', error);
+            return null;
+        }
+    };
+    static createRelease = async ({ publicKey, mint, metadata, datetime, publisherId, releaseAccount }) => {
+        const slug = await this.generateSlug(metadata);
+        const price = releaseAccount.account?.price?.toNumber() || releaseAccount?.price?.toNumber() || 0;
+        const paymentMint = releaseAccount.account?.paymentMint.toBase58() || releaseAccount?.paymentMint.toBase58();
+        const release = await Release.query().insertGraph({
+            publicKey,
+            mint,
+            metadata,
+            slug,
+            datetime,
+            publisherId,
+            price: `${price}`,
+            paymentMint,
+            archived: false
+        });
+        if (metadata.properties.tags) {
+            for await (let tag of metadata.properties.tags) {
+                const tagRecord = await Tag.findOrCreate(tag);
+                await Release.relatedQuery('tags').for(release.id).relate(tagRecord.id).onConflict(['tagId', 'releaseId']).ignore();
+            }
+        }
+        await this.processRevenueShares(releaseAccount, release);
+        tweetNewRelease(metadata, publisherId, slug);
+        return release;
+    };
+    static processRevenueShares = async (releaseData, releaseRecord) => {
+        const royaltyRecipients = releaseData.account?.royaltyRecipients || releaseData.royaltyRecipients;
+        for await (let recipient of royaltyRecipients) {
+            try {
+                if (recipient.recipientAuthority.toBase58() !== "11111111111111111111111111111111") {
+                    const recipientAccount = await Account.findOrCreate(recipient.recipientAuthority.toBase58());
+                    const revenueShares = (await recipientAccount.$relatedQuery('revenueShares')).map(revenueShare => revenueShare.id);
+                    if (!revenueShares.includes(releaseRecord.id) && recipient.percentShare.toNumber() > 0) {
+                        await Account.relatedQuery('revenueShares').for(recipientAccount.id).relate(releaseRecord.id);
+                    }
+                    else if (revenueShares.includes(releaseRecord.id) && recipient.percentShare.toNumber() === 0) {
+                        await Account.relatedQuery('revenueShares').for(recipientAccount.id).unrelate().where('id', releaseRecord.id);
+                    }
+                }
+            }
+            catch (error) {
+                console.log('error processing royaltyRecipients: ', error);
+            }
+        }
+    };
+    static generateSlug = async (metadata) => {
+        let string = metadata.name;
+        if (string.length > 200) {
+            string = string.substring(0, 200);
+        }
+        const slug = string
+            .normalize('NFKD').replace(/[\u0300-\u036F]/g, '') // remove accents and convert to closest ascii equivalent
+            .toLowerCase() // convert to lowercase
+            .replace('-', '') // remove hyphens
+            .replace(/  +/g, ' ') // remove spaces 
+            .replace(/ /g, '-') // replace spaces with hyphens
+            .replace(/[^a-zA-Z0-9-]/g, '-') // replace non-alphanumeric characters with hyphens
+            .replace(/-+/g, '-') // replace multiple hyphens with single hyphen
+            .replace(/-$/, ''); // remove trailing hyphens
+        const existingRelease = await Release.query().findOne({ slug });
+        if (existingRelease) {
+            return `${slug}-${randomStringGenerator()}`;
+        }
+        return slug;
+    };
+    format = async () => {
+        const publisher = await this.$relatedQuery('publisher');
+        const publishedThroughHub = await this.$relatedQuery('publishedThroughHub');
+        if (publishedThroughHub) {
+            this.publishedThroughHub = publishedThroughHub.publicKey;
+            this.hub = publishedThroughHub;
+            delete this.hub.id;
+            const authority = await this.hub.$relatedQuery('authority').select('publicKey');
+            this.hub.authority = authority.publicKey;
+            delete this.hub.authorityId;
+        }
+        await publisher.format();
+        this.publisher = publisher.publicKey;
+        this.publisherAccount = publisher;
+        delete this.publisherId;
+        delete this.hubId;
+        delete this.id;
+        stripHtmlIfNeeded(this.metadata, 'description');
+    };
+    static relationMappings = () => ({
+        publishedThroughHub: {
+            relation: Model.BelongsToOneRelation,
+            modelClass: Hub,
+            join: {
+                from: 'releases.hubId',
+                to: 'hubs.id',
+            },
+        },
+        publisher: {
+            relation: Model.HasOneRelation,
+            modelClass: Account,
+            join: {
+                from: 'releases.publisherId',
+                to: 'accounts.id',
+            },
+        },
+        collectors: {
+            relation: Model.ManyToManyRelation,
+            modelClass: Account,
+            join: {
+                from: 'releases.id',
+                through: {
+                    from: 'releases_collected.releaseId',
+                    to: 'releases_collected.accountId',
+                },
+                to: 'accounts.id',
+            },
+        },
+        exchanges: {
+            relation: Model.HasManyRelation,
+            modelClass: Exchange,
+            join: {
+                from: 'releases.id',
+                to: 'exchanges.releaseId',
+            },
+        },
+        hubs: {
+            relation: Model.ManyToManyRelation,
+            modelClass: Hub,
+            join: {
+                from: 'releases.id',
+                through: {
+                    from: 'hubs_releases.releaseId',
+                    to: 'hubs_releases.hubId',
+                    extra: ['hubReleasePublicKey'],
+                },
+                to: 'hubs.id',
+            },
+        },
+        posts: {
+            relation: Model.ManyToManyRelation,
+            modelClass: Post,
+            join: {
+                from: 'releases.id',
+                through: {
+                    from: 'posts_releases.releaseId',
+                    to: 'posts_releases.postId',
+                },
+                to: 'posts.id',
+            },
+        },
+        revenueShareRecipients: {
+            relation: Model.ManyToManyRelation,
+            modelClass: Account,
+            join: {
+                from: 'releases.id',
+                through: {
+                    from: 'releases_revenue_share.releaseId',
+                    to: 'releases_revenue_share.accountId',
+                },
+                to: 'accounts.id',
+            },
+        },
+        tags: {
+            relation: Model.ManyToManyRelation,
+            modelClass: Tag,
+            join: {
+                from: 'releases.id',
+                through: {
+                    from: 'tags_releases.releaseId',
+                    to: 'tags_releases.tagId',
+                },
+                to: 'tags.id',
+            },
+        },
+    });
+}

package/dist/models/Subscription.js

@@ -0,0 +1,57 @@
+import { Model } from 'objection';
+import Account from './Account.js';
+import Hub from './Hub.js';
+class Subscription extends Model {
+    static get tableName() {
+        return 'subscriptions';
+    }
+    static get idColumn() {
+        return 'id';
+    }
+    static get jsonSchema() {
+        return {
+            type: 'object',
+            required: ['datetime'],
+            properties: {
+                datetime: { type: 'string' },
+                from: { type: 'string' },
+                to: { type: 'string' },
+                subscriptionType: {
+                    type: 'string',
+                    enum: ['account', 'hub'],
+                },
+            },
+        };
+    }
+    static async findOrCreate({ from, to, datetime, subscriptionType }) {
+        let subscription = await Subscription.query().findOne({ from, to });
+        if (subscription) {
+            return subscription;
+        }
+        subscription = await Subscription.query().insert({
+            from, to, datetime, subscriptionType
+        });
+        console.log('Inserted subscription: ', from, to);
+        return subscription;
+    }
+    async format() {
+        if (this.subscriptionType === 'account') {
+            const accountTo = await Account.query().findOne({ publicKey: this.to });
+            await accountTo.format();
+            this.to = accountTo;
+            const accountFrom = await Account.query().findOne({ publicKey: this.from });
+            await accountFrom.format();
+            this.from = accountFrom;
+        }
+        else if (this.subscriptionType === 'hub') {
+            const hub = await Hub.query().findOne({ publicKey: this.to });
+            await hub.format();
+            this.to = hub;
+            const account = await Account.query().findOne({ publicKey: this.from });
+            await account.format();
+            this.from = account;
+        }
+        delete this.id;
+    }
+}
+export default Subscription;

package/dist/models/Tag.js

@@ -0,0 +1,39 @@
+import { Model } from 'objection';
+import Release from './Release.js';
+export default class Tag extends Model {
+    static tableName = 'tags';
+    static idColumn = 'id';
+    static jsonSchema = {
+        type: 'object',
+        required: ['value'],
+        properties: {
+            value: { type: 'string' },
+        },
+    };
+    static sanitizeValue = (value) => value.toLowerCase().replace('#', '').replace(',', '');
+    static findOrCreate = async (value) => {
+        const sanitizedValue = this.sanitizeValue(value);
+        let tag = await Tag.query().where('value', sanitizedValue).first();
+        if (!tag) {
+            tag = await Tag.query().insert({ value: sanitizedValue });
+        }
+        return tag;
+    };
+    format = () => {
+        delete this.id;
+    };
+    static relationMappings = () => ({
+        releases: {
+            relation: Model.ManyToManyRelation,
+            modelClass: Release,
+            join: {
+                from: 'tags.id',
+                through: {
+                    from: 'tags_releases.tagId',
+                    to: 'tags_releases.releaseId',
+                },
+                to: 'releases.id',
+            },
+        },
+    });
+}

package/dist/models/TagsReleases.js

@@ -0,0 +1,17 @@
+import { Model } from 'objection';
+export default class TagsRelease extends Model {
+    static tableName = 'tags_releases';
+    $beforeUpdate() {
+        this.updatedAt = new Date().toISOString();
+    }
+    static jsonSchema = {
+        type: 'object',
+        required: ['tagId', 'releaseId', 'createdAt', 'updatedAt'],
+        properties: {
+            tagId: { type: 'integer' },
+            releaseId: { type: 'integer' },
+            createdAt: { type: 'string' },
+            updatedAt: { type: 'string' },
+        },
+    };
+}

package/dist/models/Transaction.js

@@ -0,0 +1,148 @@
+import { Model } from 'objection';
+import Account from './Account.js';
+import Hub from './Hub.js';
+import Release from './Release.js';
+import Post from './Post.js';
+class Transaction extends Model {
+    static get tableName() {
+        return 'transactions';
+    }
+    static get idColumn() {
+        return 'id';
+    }
+    static get jsonSchema() {
+        return {
+            type: 'object',
+            required: ['txid', 'blocktime', 'type'],
+            properties: {
+                txid: { type: 'string' },
+                blocktime: { type: 'integer' },
+                type: {
+                    type: 'string',
+                    enum: [
+                        'ExchangeAccept',
+                        'ExchangeCancel',
+                        'ExchangeInit',
+                        'HubInit',
+                        'HubInitWithCredit',
+                        'HubAddCollaborator',
+                        'HubContentToggleVisibility',
+                        'HubRemoveCollaborator',
+                        'HubUpdateCollaboratorPermissions',
+                        'HubUpdateConfig',
+                        'HubAddRelease',
+                        'HubWithdraw',
+                        'PostInitViaHub',
+                        'PostInitViaHubWithReferenceRelease',
+                        'ReleaseClaim',
+                        'ReleaseCloseEdition',
+                        'ReleaseInit',
+                        'ReleaseInitWithCredit',
+                        'ReleaseInitViaHub',
+                        'ReleasePurchase',
+                        'ReleasePurchaseViaHub',
+                        'ReleaseRevenueShareCollectViaHub',
+                        'ReleaseRevenueShareCollect',
+                        'ReleaseRevenueShareTransfer',
+                        'ReleaseUpdateMetadata',
+                        'SubscriptionSubscribeAccount',
+                        'SubscriptionSubscribeHub',
+                        'SubscriptionUnsubscribe',
+                        'Unknown',
+                    ],
+                },
+            },
+        };
+    }
+    async format() {
+        const hub = await this.$relatedQuery('hub');
+        if (hub) {
+            await hub.format();
+            this.hub = hub;
+        }
+        delete this.hubId;
+        const authority = await this.$relatedQuery('authority');
+        if (authority) {
+            await authority.format();
+            this.authority = authority;
+        }
+        delete this.authorityId;
+        const release = await this.$relatedQuery('release');
+        if (release) {
+            await release.format();
+            this.release = release;
+        }
+        delete this.releaseId;
+        const post = await this.$relatedQuery('post');
+        if (post) {
+            await post.format();
+            this.post = post;
+        }
+        delete this.postId;
+        const toAccount = await this.$relatedQuery('toAccount');
+        if (toAccount) {
+            await toAccount.format();
+            this.toAccount = toAccount;
+        }
+        delete this.toAccountId;
+        const toHub = await this.$relatedQuery('toHub');
+        if (toHub) {
+            await toHub.format();
+            this.toHub = toHub;
+        }
+        delete this.toHubId;
+        this.datetime = new Date(this.blocktime * 1000).toISOString();
+        delete this.id;
+    }
+    static relationMappings = () => ({
+        authority: {
+            relation: Model.HasOneRelation,
+            modelClass: Account,
+            join: {
+                from: 'transactions.authorityId',
+                to: 'accounts.id',
+            },
+        },
+        hub: {
+            relation: Model.HasOneRelation,
+            modelClass: Hub,
+            join: {
+                from: 'transactions.hubId',
+                to: 'hubs.id',
+            },
+        },
+        release: {
+            relation: Model.HasOneRelation,
+            modelClass: Release,
+            join: {
+                from: 'transactions.releaseId',
+                to: 'releases.id',
+            },
+        },
+        post: {
+            relation: Model.HasOneRelation,
+            modelClass: Post,
+            join: {
+                from: 'transactions.postId',
+                to: 'posts.id',
+            },
+        },
+        toAccount: {
+            relation: Model.HasOneRelation,
+            modelClass: Account,
+            join: {
+                from: 'transactions.toAccountId',
+                to: 'accounts.id',
+            },
+        },
+        toHub: {
+            relation: Model.HasOneRelation,
+            modelClass: Hub,
+            join: {
+                from: 'transactions.toHubId',
+                to: 'hubs.id',
+            },
+        },
+    });
+}
+export default Transaction;

package/dist/models/Verification.js

@@ -0,0 +1,50 @@
+import { Model } from 'objection';
+import Account from './Account.js';
+export default class Verification extends Model {
+    static get tableName() {
+        return 'verifications';
+    }
+    static get idColumn() {
+        return 'id';
+    }
+    static get jsonSchema() {
+        return {
+            type: 'object',
+            required: ['publicKey', 'type', 'value'],
+            properties: {
+                publicKey: { type: 'string' },
+                type: {
+                    type: 'string',
+                    enum: [
+                        'soundcloud',
+                        'instagram',
+                        'twitter',
+                        'ethereum',
+                    ],
+                },
+                value: { type: 'string' },
+                displayName: { type: 'string' },
+                image: { type: 'string' },
+                description: { type: 'string' },
+            },
+        };
+    }
+    async format() {
+        delete this.id;
+        const account = await this.$relatedQuery('account');
+        delete this.accountId;
+        if (account) {
+            this.account = account.publicKey;
+        }
+    }
+    static relationMappings = () => ({
+        account: {
+            relation: Model.BelongsToOneRelation,
+            modelClass: Account,
+            join: {
+                from: 'verifications.accountId',
+                to: 'accounts.id',
+            },
+        },
+    });
+}

package/dist/models/index.js

@@ -0,0 +1,21 @@
+import Account from './Account.js';
+import Exchange from './Exchange.js';
+import Hub from './Hub.js';
+import Post from './Post.js';
+import Release from './Release.js';
+import Subscription from './Subscription.js';
+import Tag from './Tag.js';
+import Transaction from './Transaction.js';
+import Verification from './Verification.js';
+const models = {
+    Account,
+    Exchange,
+    Hub,
+    Post,
+    Release,
+    Subscription,
+    Tag,
+    Transaction,
+    Verification,
+};
+export default models;

package/dist/seeds/1_accounts_profile.js

@@ -0,0 +1,22 @@
+import 'dotenv/config';
+import axios from 'axios';
+import { Account, connectDb } from '../index.js';
+export const seed = async () => {
+    await connectDb();
+    const accountsWithoutHandle = await Account.query().whereNull('handle');
+    for await (let account of accountsWithoutHandle) {
+        try {
+            const response = await axios.get(`${process.env.ID_SERVER_ENDPOINT}/profile/${account.publicKey}`);
+            await account.$query().patch({
+                handle: response.data.profile.handle,
+                displayName: response.data.profile.displayName,
+                image: response.data.profile.image,
+                description: response.data.profile.description,
+            });
+            console.log('Updated Account:', account.handle, account.publicKey);
+        }
+        catch (error) {
+            console.log('Error updating Account', account.publicKey, error);
+        }
+    }
+};

package/dist/utils/index.js

@@ -0,0 +1,45 @@
+import striptags from 'striptags';
+import { TwitterApi } from 'twitter-api-v2';
+import Account from '../models/Account.js';
+const TWEET_DELAY = 360000; // 6 minutes
+const NINA_DOMAIN = 'https://ninaprotocol.com';
+const removeQuotesFromStartAndEndOfString = (string) => {
+    return string.substring(1, string.length - 1).substring(-1, string.length - 1);
+};
+export const stripHtmlIfNeeded = (object, value) => {
+    let strippedDescription = striptags(object[value], [], ' ');
+    strippedDescription = strippedDescription.replace(' ', ' ');
+    if (strippedDescription !== object[value]) {
+        object[value + "Html"] = object[value];
+        object[value] = removeQuotesFromStartAndEndOfString(strippedDescription);
+    }
+};
+export const decode = (byteArray) => {
+    return new TextDecoder().decode(new Uint8Array(byteArray)).replaceAll(/\u0000/g, '');
+};
+export const tweetNewRelease = async (metadata, publisherId, slug) => {
+    if (process.env.TWITTER_API_SECRET) {
+        try {
+            await new Promise(resolve => setTimeout(resolve, TWEET_DELAY));
+            const client = new TwitterApi({
+                appKey: process.env.TWITTER_API_KEY,
+                appSecret: process.env.TWITTER_API_SECRET,
+                accessToken: process.env.TWITTER_ACCESS_TOKEN,
+                accessSecret: process.env.TWITTER_ACCESS_TOKEN_SECRET,
+            });
+            let text = (`${metadata.properties.artist ? `${metadata.properties.artist} - ` : ''}${metadata.properties.title}`).substr(0, 250);
+            const publisher = await Account.query().findById(publisherId);
+            if (publisher) {
+                const twitterVerification = (await publisher.$relatedQuery('verifications').where('type', 'twitter').andWhere('active', true))[0];
+                if (twitterVerification) {
+                    text = `${text} (@${twitterVerification.value})`;
+                }
+            }
+            text = `${text} ${NINA_DOMAIN}/releases/${slug}`;
+            await client.v2.tweet(text);
+        }
+        catch (error) {
+            console.warn('error sending new release tweet: ', error, metadata);
+        }
+    }
+};