@nina-protocol/nina-db 0.0.90 → 0.0.92

package/dist/migrations/20241121155034_subscription_public_key_nullable.js

@@ -1,15 +0,0 @@
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-export const up = function (knex) {
-    return knex.schema.alterTable('subscriptions', table => {
-        table.dropColumn('publicKey');
-    });
-};
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-export const down = function (knex) {
-};

package/dist/migrations/20250120215722_add_ref_columns.js

@@ -1,18 +0,0 @@
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-export const up = function (knex) {
-    return knex.schema.table('subscriptions', table => {
-        table.string('ref').nullable();
-    });
-};
-/**
- * @param { import("knex").Knex } knex
- * @returns { Promise<void> }
- */
-export const down = function (knex) {
-    return knex.schema.table('subscriptions', table => {
-        table.dropColumn('ref');
-    });
-};

package/dist/models/Account.js

@@ -1,122 +0,0 @@
-import { Model } from 'objection';
-import Exchange from './Exchange.js';
-import Hub from './Hub.js';
-import Post from './Post.js';
-import Release from './Release.js';
-import Verification from './Verification.js';
-import Subscription from './Subscription.js';
-export default class Account extends Model {
-    static tableName = 'accounts';
-    static idColumn = 'id';
-    static jsonSchema = {
-        type: 'object',
-        required: ['publicKey'],
-        properties: {
-            publicKey: { type: 'string' },
-            image: { type: 'string' },
-            description: { type: 'string' },
-            displayName: { type: 'string' },
-            handle: { type: 'string' },
-        },
-    };
-    static findOrCreate = async (publicKey) => {
-        let account = await Account.query().findOne({ publicKey });
-        if (account) {
-            return account;
-        }
-        account = await Account.query().insert({ publicKey });
-        console.log('Inserted Account: ', publicKey);
-        return account;
-    };
-    format = async () => {
-        const verifications = await this.$relatedQuery('verifications').where('active', true);
-        if (verifications) {
-            for await (let verification of verifications) {
-                await verification.format();
-            }
-            this.verifications = verifications;
-        }
-        delete this.id;
-        const followers = await Subscription.query().where('to', this.publicKey).range(0, 0);
-        this.followers = followers.total;
-    };
-    static relationMappings = () => ({
-        published: {
-            relation: Model.HasManyRelation,
-            modelClass: Release,
-            join: {
-                from: 'accounts.id',
-                to: 'releases.publisherId'
-            }
-        },
-        collected: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Release,
-            join: {
-                from: 'accounts.id',
-                through: {
-                    from: 'releases_collected.accountId',
-                    to: 'releases_collected.releaseId',
-                },
-                to: 'releases.id'
-            }
-        },
-        exchangesInitialized: {
-            relation: Model.HasManyRelation,
-            modelClass: Exchange,
-            join: {
-                from: 'accounts.id',
-                to: 'exchanges.initializerId',
-            },
-        },
-        exchangesCompleted: {
-            relation: Model.HasManyRelation,
-            modelClass: Exchange,
-            join: {
-                from: 'accounts.id',
-                to: 'exchanges.completedById',
-            },
-        },
-        hubs: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Hub,
-            join: {
-                from: 'accounts.id',
-                through: {
-                    from: 'hubs_collaborators.accountId',
-                    to: 'hubs_collaborators.hubId',
-                    extra: ['hubCollaboratorPublicKey'],
-                },
-                to: 'hubs.id',
-            },
-        },
-        posts: {
-            relation: Model.HasManyRelation,
-            modelClass: Post,
-            join: {
-                from: 'accounts.id',
-                to: 'posts.publisherId',
-            },
-        },
-        revenueShares: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Release,
-            join: {
-                from: 'accounts.id',
-                through: {
-                    from: 'releases_revenue_share.accountId',
-                    to: 'releases_revenue_share.releaseId',
-                },
-                to: 'releases.id',
-            },
-        },
-        verifications: {
-            relation: Model.HasManyRelation,
-            modelClass: Verification,
-            join: {
-                from: 'accounts.id',
-                to: 'verifications.accountId',
-            },
-        },
-    });
-}

package/dist/models/Exchange.js

@@ -1,62 +0,0 @@
-import { Model } from 'objection';
-import Account from './Account.js';
-import Release from './Release.js';
-export default class Exchange extends Model {
-    static tableName = 'exchanges';
-    static idColum = 'id';
-    static jsonSchema = {
-        type: 'object',
-        required: ['publicKey', 'isSale', 'initializerAmount', 'expectedAmount', 'cancelled', 'createdAt'],
-        properties: {
-            publicKey: { type: 'string' },
-            isSale: { type: 'boolean' },
-            initializerAmount: { type: 'number' },
-            expectedAmount: { type: 'number' },
-            cancelled: { type: 'boolean' },
-            createdAt: { type: 'string' },
-            updatedAt: { type: 'string' },
-        },
-    };
-    format = async () => {
-        const initializer = await this.$relatedQuery('initializer');
-        const completedBy = await this.$relatedQuery('completedBy');
-        const release = await this.$relatedQuery('release').select('publicKey');
-        if (completedBy) {
-            await completedBy.format();
-            this.completedBy = completedBy;
-        }
-        this.release = release.publicKey;
-        await initializer.format();
-        this.initializer = initializer;
-        delete this.id;
-        delete this.initializerId;
-        delete this.completedById;
-        delete this.releaseId;
-    };
-    static relationMappings = () => ({
-        initializer: {
-            relation: Model.HasOneRelation,
-            modelClass: Account,
-            join: {
-                from: 'exchanges.initializerId',
-                to: 'accounts.id',
-            },
-        },
-        completedBy: {
-            relation: Model.HasOneRelation,
-            modelClass: Account,
-            join: {
-                from: 'exchanges.completedById',
-                to: 'accounts.id',
-            },
-        },
-        release: {
-            relation: Model.HasOneRelation,
-            modelClass: Release,
-            join: {
-                from: 'exchanges.releaseId',
-                to: 'releases.id',
-            },
-        },
-    });
-}

package/dist/models/Hub.js

@@ -1,86 +0,0 @@
-import { Model } from 'objection';
-import { stripHtmlIfNeeded } from '../utils/index.js';
-import Account from './Account.js';
-import Release from './Release.js';
-import Post from './Post.js';
-import Subscription from './Subscription.js';
-export default class Hub extends Model {
-    static get tableName() {
-        return 'hubs';
-    }
-    static get idColumn() {
-        return 'id';
-    }
-    static get jsonSchema() {
-        return {
-            type: 'object',
-            required: ['publicKey', 'handle', 'data', 'dataUri', 'datetime'],
-            properties: {
-                publicKey: { type: 'string' },
-                handle: { type: 'string' },
-                data: { type: 'object' },
-                dataUri: { type: 'string' },
-                datetime: { type: 'string' },
-                updatedAt: { type: 'string' },
-            },
-        };
-    }
-    async format() {
-        const authority = await this.$relatedQuery('authority').select('publicKey');
-        this.authority = authority.publicKey;
-        delete this.authorityId;
-        delete this.id;
-        stripHtmlIfNeeded(this.data, 'description');
-        const followers = await Subscription.query().where('to', this.publicKey).range(0, 0);
-        this.followers = followers.total;
-    }
-    static relationMappings = () => ({
-        authority: {
-            relation: Model.HasOneRelation,
-            modelClass: Account,
-            join: {
-                from: 'hubs.authorityId',
-                to: 'accounts.id',
-            },
-        },
-        collaborators: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Account,
-            join: {
-                from: 'hubs.id',
-                through: {
-                    from: 'hubs_collaborators.hubId',
-                    to: 'hubs_collaborators.accountId',
-                    extra: ['hubCollaboratorPublicKey'],
-                },
-                to: 'accounts.id',
-            },
-        },
-        posts: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Post,
-            join: {
-                from: 'hubs.id',
-                through: {
-                    from: 'hubs_posts.hubId',
-                    to: 'hubs_posts.postId',
-                    extra: ['hubPostPublicKey'],
-                },
-                to: 'posts.id',
-            },
-        },
-        releases: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Release,
-            join: {
-                from: 'hubs.id',
-                through: {
-                    from: 'hubs_releases.hubId',
-                    to: 'hubs_releases.releaseId',
-                    extra: ['hubReleasePublicKey', 'visible'],
-                },
-                to: 'releases.id',
-            },
-        },
-    });
-}

package/dist/models/Post.js

@@ -1,84 +0,0 @@
-import { Model } from 'objection';
-import { stripHtmlIfNeeded } from '../utils/index.js';
-import Account from './Account.js';
-import Hub from './Hub.js';
-import Release from './Release.js';
-class Post extends Model {
-    static get tableName() {
-        return 'posts';
-    }
-    static get idColumn() {
-        return 'id';
-    }
-    static get jsonSchema() {
-        return {
-            type: 'object',
-            required: ['publicKey', 'data', 'datetime', 'version'],
-            properties: {
-                publicKey: { type: 'string' },
-                data: { type: 'object' },
-                datetime: { type: 'string' },
-                version: { type: 'string' },
-            },
-        };
-    }
-    async format() {
-        const publisher = await this.$relatedQuery('publisher').select('publicKey');
-        const publishedThroughHub = await this.$relatedQuery('publishedThroughHub');
-        this.publisher = publisher.publicKey;
-        if (publishedThroughHub) {
-            this.publishedThroughHub = publishedThroughHub.publicKey;
-            this.hub = publishedThroughHub;
-            delete this.hub.id;
-            delete this.hub.authorityId;
-        }
-        delete this.publisherId;
-        delete this.id;
-        delete this.hubId;
-        stripHtmlIfNeeded(this.data, 'body');
-    }
-    static relationMappings = () => ({
-        publishedThroughHub: {
-            relation: Model.BelongsToOneRelation,
-            modelClass: Hub,
-            join: {
-                from: 'posts.hubId',
-                to: 'hubs.id',
-            },
-        },
-        publisher: {
-            relation: Model.HasOneRelation,
-            modelClass: Account,
-            join: {
-                from: 'posts.publisherId',
-                to: 'accounts.id',
-            },
-        },
-        hubs: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Hub,
-            join: {
-                from: 'posts.id',
-                through: {
-                    from: 'hubs_posts.postId',
-                    to: 'hubs_posts.hubId',
-                    extra: ['hubPostPublicKey'],
-                },
-                to: 'hubs.id',
-            },
-        },
-        releases: {
-            relation: Model.ManyToManyRelation,
-            modelClass: Release,
-            join: {
-                from: 'posts.id',
-                through: {
-                    from: 'posts_releases.postId',
-                    to: 'posts_releases.releaseId',
-                },
-                to: 'releases.id',
-            },
-        },
-    });
-}
-export default Post;

package/dist/models/Release.js

@@ -1,282 +0,0 @@
-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',
-            },
-        },
-    });
-}