@earbug/db-models 0.0.15 → 0.0.17

package/.github/workflows/publish.yaml

@@ -0,0 +1,54 @@
+name: Regenerate Models and Publish
+
+on:
+  repository_dispatch:
+    types: [migration_completed]
+
+jobs:
+  publish:
+    name: Regenerate, Build, and Publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+
+      - run: npm ci
+
+      - name: Patch sequelize-auto to support citext
+        run: |
+          sed -i 's/\^(char/\^(citext|char/' \
+            node_modules/sequelize-auto/lib/auto-generator.js
+
+      - name: Generate models from dev database
+        run: |
+          npx sequelize-auto -l ts --cm=p --cf=p --cp=c -o "./models" -a ./model_options.json \
+            -d earbug_live -h "$DEV_EB_DB_HOST" -u postgres -x "$DEV_EB_DB_USER_PASSWORD" -p 5432 -e postgres \
+            -T harvested_article article_to_artist_relation
+        env:
+          DEV_EB_DB_HOST: ${{ secrets.DEV_EB_DB_HOST }}
+          DEV_EB_DB_USER_PASSWORD: ${{ secrets.DEV_EB_DB_USER_PASSWORD }}
+
+      - name: Build
+        run: npm run build
+
+      - name: Bump patch version
+        id: version
+        run: echo "version=$(npm version patch --no-git-tag-version)" >> $GITHUB_OUTPUT
+
+      - name: Publish to npm
+        run: npm publish --access public
+
+      - name: Commit and push changes
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add models/ dist/ package.json
+          git commit -m "${{ steps.version.outputs.version }} — regenerate models and publish"
+          git push

package/.nvmrc

@@ -1 +1 @@
-20
+24

package/dist/AppUser.d.ts

@@ -11,7 +11,9 @@ import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum
 import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
 import type { RadioShow, RadioShowId } from './RadioShow';
 import type { State, StateId } from './State';
+import type { UserComments, UserCommentsId } from './UserComments';
 import type { UserContacts, UserContactsId } from './UserContacts';
+import type { UserLikes, UserLikesId } from './UserLikes';
 export interface AppUserAttributes {
     email: string;
     firstName: string;
@@ -179,6 +181,17 @@ export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAtt
     hasRadioShow: Sequelize.HasManyHasAssociationMixin<RadioShow, RadioShowId>;
     hasRadioShows: Sequelize.HasManyHasAssociationsMixin<RadioShow, RadioShowId>;
     countRadioShows: Sequelize.HasManyCountAssociationsMixin;
+    userComments: UserComments[];
+    getUserComments: Sequelize.HasManyGetAssociationsMixin<UserComments>;
+    setUserComments: Sequelize.HasManySetAssociationsMixin<UserComments, UserCommentsId>;
+    addUserComment: Sequelize.HasManyAddAssociationMixin<UserComments, UserCommentsId>;
+    addUserComments: Sequelize.HasManyAddAssociationsMixin<UserComments, UserCommentsId>;
+    createUserComment: Sequelize.HasManyCreateAssociationMixin<UserComments>;
+    removeUserComment: Sequelize.HasManyRemoveAssociationMixin<UserComments, UserCommentsId>;
+    removeUserComments: Sequelize.HasManyRemoveAssociationsMixin<UserComments, UserCommentsId>;
+    hasUserComment: Sequelize.HasManyHasAssociationMixin<UserComments, UserCommentsId>;
+    hasUserComments: Sequelize.HasManyHasAssociationsMixin<UserComments, UserCommentsId>;
+    countUserComments: Sequelize.HasManyCountAssociationsMixin;
     userContacts: UserContacts[];
     getUserContacts: Sequelize.HasManyGetAssociationsMixin<UserContacts>;
     setUserContacts: Sequelize.HasManySetAssociationsMixin<UserContacts, UserContactsId>;
@@ -190,6 +203,17 @@ export declare class AppUser extends Model<AppUserAttributes, AppUserCreationAtt
     hasUserContact: Sequelize.HasManyHasAssociationMixin<UserContacts, UserContactsId>;
     hasUserContacts: Sequelize.HasManyHasAssociationsMixin<UserContacts, UserContactsId>;
     countUserContacts: Sequelize.HasManyCountAssociationsMixin;
+    userLikes: UserLikes[];
+    getUserLikes: Sequelize.HasManyGetAssociationsMixin<UserLikes>;
+    setUserLikes: Sequelize.HasManySetAssociationsMixin<UserLikes, UserLikesId>;
+    addUserLike: Sequelize.HasManyAddAssociationMixin<UserLikes, UserLikesId>;
+    addUserLikes: Sequelize.HasManyAddAssociationsMixin<UserLikes, UserLikesId>;
+    createUserLike: Sequelize.HasManyCreateAssociationMixin<UserLikes>;
+    removeUserLike: Sequelize.HasManyRemoveAssociationMixin<UserLikes, UserLikesId>;
+    removeUserLikes: Sequelize.HasManyRemoveAssociationsMixin<UserLikes, UserLikesId>;
+    hasUserLike: Sequelize.HasManyHasAssociationMixin<UserLikes, UserLikesId>;
+    hasUserLikes: Sequelize.HasManyHasAssociationsMixin<UserLikes, UserLikesId>;
+    countUserLikes: Sequelize.HasManyCountAssociationsMixin;
     state: State;
     getState: Sequelize.BelongsToGetAssociationMixin<State>;
     setState: Sequelize.BelongsToSetAssociationMixin<State, StateId>;

package/dist/CanonArtist.d.ts

@@ -5,6 +5,9 @@ import type { CanonArtistImageHarvested, CanonArtistImageHarvestedId } from './C
 import type { CanonArtistTrackRelation, CanonArtistTrackRelationId } from './CanonArtistTrackRelation';
 import type { CanonToPlatformArtistRelation, CanonToPlatformArtistRelationId } from './CanonToPlatformArtistRelation';
 import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { MerchItem, MerchItemId } from './MerchItem';
+import type { MerchOrchestration, MerchOrchestrationId } from './MerchOrchestration';
+import type { NewsArticle, NewsArticleId } from './NewsArticle';
 import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
 import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
 export interface CanonArtistAttributes {
@@ -20,10 +23,13 @@ export interface CanonArtistAttributes {
     lastImageHarvestAttempt?: Date;
     merchHarvestDay?: number;
     newsHarvestDay?: number;
+    harvestPopularity?: number;
+    lastGenreHarvestAttempt?: Date;
+    genreHarvestCount: number;
 }
 export type CanonArtistPk = "id";
 export type CanonArtistId = CanonArtist[CanonArtistPk];
-export type CanonArtistOptionalAttributes = "description" | "id" | "createDate" | "updateDate" | "hasThumbnailPhoto" | "images" | "lastImageHarvestAttempt" | "merchHarvestDay" | "newsHarvestDay";
+export type CanonArtistOptionalAttributes = "description" | "id" | "createDate" | "updateDate" | "hasThumbnailPhoto" | "images" | "lastImageHarvestAttempt" | "merchHarvestDay" | "newsHarvestDay" | "harvestPopularity" | "lastGenreHarvestAttempt" | "genreHarvestCount";
 export type CanonArtistCreationAttributes = Optional<CanonArtistAttributes, CanonArtistOptionalAttributes>;
 export declare class CanonArtist extends Model<CanonArtistAttributes, CanonArtistCreationAttributes> implements CanonArtistAttributes {
     name: string;
@@ -38,6 +44,9 @@ export declare class CanonArtist extends Model<CanonArtistAttributes, CanonArtis
     lastImageHarvestAttempt?: Date;
     merchHarvestDay?: number;
     newsHarvestDay?: number;
+    harvestPopularity?: number;
+    lastGenreHarvestAttempt?: Date;
+    genreHarvestCount: number;
     canonArtistAlbumRelations: CanonArtistAlbumRelation[];
     getCanonArtistAlbumRelations: Sequelize.HasManyGetAssociationsMixin<CanonArtistAlbumRelation>;
     setCanonArtistAlbumRelations: Sequelize.HasManySetAssociationsMixin<CanonArtistAlbumRelation, CanonArtistAlbumRelationId>;
@@ -93,6 +102,39 @@ export declare class CanonArtist extends Model<CanonArtistAttributes, CanonArtis
     hasCanonTrackIdCanonTrackCanonArtistTrackRelation: Sequelize.BelongsToManyHasAssociationMixin<CanonTrack, CanonTrackId>;
     hasCanonTrackIdCanonTrackCanonArtistTrackRelations: Sequelize.BelongsToManyHasAssociationsMixin<CanonTrack, CanonTrackId>;
     countCanonTrackIdCanonTrackCanonArtistTrackRelations: Sequelize.BelongsToManyCountAssociationsMixin;
+    merchItems: MerchItem[];
+    getMerchItems: Sequelize.HasManyGetAssociationsMixin<MerchItem>;
+    setMerchItems: Sequelize.HasManySetAssociationsMixin<MerchItem, MerchItemId>;
+    addMerchItem: Sequelize.HasManyAddAssociationMixin<MerchItem, MerchItemId>;
+    addMerchItems: Sequelize.HasManyAddAssociationsMixin<MerchItem, MerchItemId>;
+    createMerchItem: Sequelize.HasManyCreateAssociationMixin<MerchItem>;
+    removeMerchItem: Sequelize.HasManyRemoveAssociationMixin<MerchItem, MerchItemId>;
+    removeMerchItems: Sequelize.HasManyRemoveAssociationsMixin<MerchItem, MerchItemId>;
+    hasMerchItem: Sequelize.HasManyHasAssociationMixin<MerchItem, MerchItemId>;
+    hasMerchItems: Sequelize.HasManyHasAssociationsMixin<MerchItem, MerchItemId>;
+    countMerchItems: Sequelize.HasManyCountAssociationsMixin;
+    merchOrchestrations: MerchOrchestration[];
+    getMerchOrchestrations: Sequelize.HasManyGetAssociationsMixin<MerchOrchestration>;
+    setMerchOrchestrations: Sequelize.HasManySetAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    addMerchOrchestration: Sequelize.HasManyAddAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+    addMerchOrchestrations: Sequelize.HasManyAddAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    createMerchOrchestration: Sequelize.HasManyCreateAssociationMixin<MerchOrchestration>;
+    removeMerchOrchestration: Sequelize.HasManyRemoveAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+    removeMerchOrchestrations: Sequelize.HasManyRemoveAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    hasMerchOrchestration: Sequelize.HasManyHasAssociationMixin<MerchOrchestration, MerchOrchestrationId>;
+    hasMerchOrchestrations: Sequelize.HasManyHasAssociationsMixin<MerchOrchestration, MerchOrchestrationId>;
+    countMerchOrchestrations: Sequelize.HasManyCountAssociationsMixin;
+    newsArticles: NewsArticle[];
+    getNewsArticles: Sequelize.HasManyGetAssociationsMixin<NewsArticle>;
+    setNewsArticles: Sequelize.HasManySetAssociationsMixin<NewsArticle, NewsArticleId>;
+    addNewsArticle: Sequelize.HasManyAddAssociationMixin<NewsArticle, NewsArticleId>;
+    addNewsArticles: Sequelize.HasManyAddAssociationsMixin<NewsArticle, NewsArticleId>;
+    createNewsArticle: Sequelize.HasManyCreateAssociationMixin<NewsArticle>;
+    removeNewsArticle: Sequelize.HasManyRemoveAssociationMixin<NewsArticle, NewsArticleId>;
+    removeNewsArticles: Sequelize.HasManyRemoveAssociationsMixin<NewsArticle, NewsArticleId>;
+    hasNewsArticle: Sequelize.HasManyHasAssociationMixin<NewsArticle, NewsArticleId>;
+    hasNewsArticles: Sequelize.HasManyHasAssociationsMixin<NewsArticle, NewsArticleId>;
+    countNewsArticles: Sequelize.HasManyCountAssociationsMixin;
     canonAlbumIdPlatformAlbumCanonArtistAlbumRelations: PlatformAlbum[];
     getCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
     setCanonAlbumIdPlatformAlbumCanonArtistAlbumRelations: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;

package/dist/CanonArtist.js

@@ -82,14 +82,30 @@ class CanonArtist extends sequelize_1.Model {
                 field: 'last_image_harvest_attempt'
             },
             merchHarvestDay: {
-                type: sequelize_1.DataTypes.NUMBER,
+                type: sequelize_1.DataTypes.SMALLINT,
                 allowNull: true,
                 field: 'merch_harvest_day'
             },
             newsHarvestDay: {
-                type: sequelize_1.DataTypes.NUMBER,
+                type: sequelize_1.DataTypes.SMALLINT,
                 allowNull: true,
                 field: 'news_harvest_day'
+            },
+            harvestPopularity: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: true,
+                field: 'harvest_popularity'
+            },
+            lastGenreHarvestAttempt: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+                field: 'last_genre_harvest_attempt'
+            },
+            genreHarvestCount: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: false,
+                defaultValue: 0,
+                field: 'genre_harvest_count'
             }
         }, {
             sequelize,

package/dist/GuestUser.d.ts

@@ -0,0 +1,42 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+export interface GuestUserAttributes {
+    firstName: string;
+    lastName?: string;
+    jukeboxSessionId: string;
+    ipAddress?: string;
+    id: string;
+    createDate: Date;
+    updateDate: Date;
+}
+export type GuestUserPk = "id";
+export type GuestUserId = GuestUser[GuestUserPk];
+export type GuestUserOptionalAttributes = "lastName" | "ipAddress" | "id" | "createDate" | "updateDate";
+export type GuestUserCreationAttributes = Optional<GuestUserAttributes, GuestUserOptionalAttributes>;
+export declare class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttributes> implements GuestUserAttributes {
+    firstName: string;
+    lastName?: string;
+    jukeboxSessionId: string;
+    ipAddress?: string;
+    id: string;
+    createDate: Date;
+    updateDate: Date;
+    jukeboxQueueEntries: JukeboxQueueEntry[];
+    getJukeboxQueueEntries: Sequelize.HasManyGetAssociationsMixin<JukeboxQueueEntry>;
+    setJukeboxQueueEntries: Sequelize.HasManySetAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntry: Sequelize.HasManyAddAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    addJukeboxQueueEntries: Sequelize.HasManyAddAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    createJukeboxQueueEntry: Sequelize.HasManyCreateAssociationMixin<JukeboxQueueEntry>;
+    removeJukeboxQueueEntry: Sequelize.HasManyRemoveAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    removeJukeboxQueueEntries: Sequelize.HasManyRemoveAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntry: Sequelize.HasManyHasAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    hasJukeboxQueueEntries: Sequelize.HasManyHasAssociationsMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+    countJukeboxQueueEntries: Sequelize.HasManyCountAssociationsMixin;
+    jukeboxSession: JukeboxSession;
+    getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+    setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+    createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof GuestUser;
+}

package/dist/GuestUser.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuestUser = void 0;
+const Sequelize = __importStar(require("sequelize"));
+const sequelize_1 = require("sequelize");
+class GuestUser extends sequelize_1.Model {
+    static initModel(sequelize) {
+        return GuestUser.init({
+            firstName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: false,
+                field: 'first_name'
+            },
+            lastName: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'last_name'
+            },
+            jukeboxSessionId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                references: {
+                    model: 'jukebox_session',
+                    key: 'id'
+                },
+                field: 'jukebox_session_id'
+            },
+            ipAddress: {
+                type: sequelize_1.DataTypes.TEXT,
+                allowNull: true,
+                field: 'ip_address'
+            },
+            id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+                primaryKey: true
+            },
+            createDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'create_date'
+            },
+            updateDate: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+                field: 'update_date'
+            }
+        }, {
+            sequelize,
+            tableName: 'guest_user',
+            schema: 'eb',
+            timestamps: false,
+            indexes: [
+                {
+                    name: "guest_user_pkey",
+                    unique: true,
+                    fields: [
+                        { name: "id" },
+                    ]
+                },
+            ]
+        });
+    }
+}
+exports.GuestUser = GuestUser;

package/dist/JukeboxQueueEntry.d.ts

@@ -2,15 +2,15 @@ import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
 import type { AppUser, AppUserId } from './AppUser';
 import type { CanonTrack, CanonTrackId } from './CanonTrack';
+import type { GuestUser, GuestUserId } from './GuestUser';
 import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
 import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { PlatformTrack, PlatformTrackId } from './PlatformTrack';
 import type { PlaybackStatusType, PlaybackStatusTypeId } from './PlaybackStatusType';
 import type { TrackDeletionReason, TrackDeletionReasonId } from './TrackDeletionReason';
 export interface JukeboxQueueEntryAttributes {
     jukeboxSessionId: string;
-    trackId: string;
     playbackPriority?: number;
-    trackAddedUserId: string;
     playbackStarted?: Date;
     id: string;
     createdAt: Date;
@@ -18,18 +18,20 @@ export interface JukeboxQueueEntryAttributes {
     setOrder: number;
     trackDeletionReasonId: number;
     playbackStatusTypeId: number;
+    trackId?: string;
+    trackAddedUserId?: string;
     trackThumbsUp?: string[];
     trackThumbsDown?: string[];
+    platformTrackId?: string;
+    trackAddedGuestUserId?: string;
 }
 export type JukeboxQueueEntryPk = "id";
 export type JukeboxQueueEntryId = JukeboxQueueEntry[JukeboxQueueEntryPk];
-export type JukeboxQueueEntryOptionalAttributes = "playbackPriority" | "playbackStarted" | "id" | "createdAt" | "updatedAt" | "setOrder" | "trackDeletionReasonId" | "playbackStatusTypeId" | "trackThumbsUp" | "trackThumbsDown";
+export type JukeboxQueueEntryOptionalAttributes = "playbackPriority" | "playbackStarted" | "id" | "createdAt" | "updatedAt" | "setOrder" | "trackDeletionReasonId" | "playbackStatusTypeId" | "trackId" | "trackAddedUserId" | "trackThumbsUp" | "trackThumbsDown" | "platformTrackId" | "trackAddedGuestUserId";
 export type JukeboxQueueEntryCreationAttributes = Optional<JukeboxQueueEntryAttributes, JukeboxQueueEntryOptionalAttributes>;
 export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, JukeboxQueueEntryCreationAttributes> implements JukeboxQueueEntryAttributes {
     jukeboxSessionId: string;
-    trackId: string;
     playbackPriority?: number;
-    trackAddedUserId: string;
     playbackStarted?: Date;
     id: string;
     createdAt: Date;
@@ -37,8 +39,12 @@ export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes
     setOrder: number;
     trackDeletionReasonId: number;
     playbackStatusTypeId: number;
+    trackId?: string;
+    trackAddedUserId?: string;
     trackThumbsUp?: string[];
     trackThumbsDown?: string[];
+    platformTrackId?: string;
+    trackAddedGuestUserId?: string;
     trackAddedUser: AppUser;
     getTrackAddedUser: Sequelize.BelongsToGetAssociationMixin<AppUser>;
     setTrackAddedUser: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
@@ -47,6 +53,10 @@ export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes
     getTrack: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
     setTrack: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
     createTrack: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+    trackAddedGuestUser: GuestUser;
+    getTrackAddedGuestUser: Sequelize.BelongsToGetAssociationMixin<GuestUser>;
+    setTrackAddedGuestUser: Sequelize.BelongsToSetAssociationMixin<GuestUser, GuestUserId>;
+    createTrackAddedGuestUser: Sequelize.BelongsToCreateAssociationMixin<GuestUser>;
     jukeboxUsers: JukeboxUser[];
     getJukeboxUsers: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
     setJukeboxUsers: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
@@ -62,6 +72,10 @@ export declare class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes
     getJukeboxSession: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
     setJukeboxSession: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
     createJukeboxSession: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+    platformTrack: PlatformTrack;
+    getPlatformTrack: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+    setPlatformTrack: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+    createPlatformTrack: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
     playbackStatusType: PlaybackStatusType;
     getPlaybackStatusType: Sequelize.BelongsToGetAssociationMixin<PlaybackStatusType>;
     setPlaybackStatusType: Sequelize.BelongsToSetAssociationMixin<PlaybackStatusType, PlaybackStatusTypeId>;

package/dist/JukeboxQueueEntry.js

@@ -38,29 +38,11 @@ class JukeboxQueueEntry extends sequelize_1.Model {
                 },
                 field: 'jukebox_session_id'
             },
-            trackId: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'canon_track',
-                    key: 'id'
-                },
-                field: 'track_id'
-            },
             playbackPriority: {
                 type: sequelize_1.DataTypes.DECIMAL,
                 allowNull: true,
                 field: 'playback_priority'
             },
-            trackAddedUserId: {
-                type: sequelize_1.DataTypes.UUID,
-                allowNull: false,
-                references: {
-                    model: 'app_user',
-                    key: 'id'
-                },
-                field: 'track_added_user_id'
-            },
             playbackStarted: {
                 type: sequelize_1.DataTypes.DATE,
                 allowNull: true,
@@ -110,6 +92,24 @@ class JukeboxQueueEntry extends sequelize_1.Model {
                 },
                 field: 'playback_status_type_id'
             },
+            trackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'canon_track',
+                    key: 'id'
+                },
+                field: 'track_id'
+            },
+            trackAddedUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'app_user',
+                    key: 'id'
+                },
+                field: 'track_added_user_id'
+            },
             trackThumbsUp: {
                 type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.UUID),
                 allowNull: true,
@@ -121,6 +121,24 @@ class JukeboxQueueEntry extends sequelize_1.Model {
                 allowNull: true,
                 defaultValue: ["ARRAY[]"],
                 field: 'track_thumbs_down'
+            },
+            platformTrackId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'platform_track',
+                    key: 'id'
+                },
+                field: 'platform_track_id'
+            },
+            trackAddedGuestUserId: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'guest_user',
+                    key: 'id'
+                },
+                field: 'track_added_guest_user_id'
             }
         }, {
             sequelize,

package/dist/JukeboxSession.d.ts

@@ -1,5 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { Model, Optional } from 'sequelize';
+import type { GuestUser, GuestUserId } from './GuestUser';
 import type { JukeboxAccessType, JukeboxAccessTypeId } from './JukeboxAccessType';
 import type { JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId } from './JukeboxCanonGenreRelation';
 import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
@@ -10,6 +11,8 @@ import type { JukeboxTerminationCondition, JukeboxTerminationConditionId } from
 import type { JukeboxType, JukeboxTypeId } from './JukeboxType';
 import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
 import type { Notification, NotificationId } from './Notification';
+import type { UserComments, UserCommentsId } from './UserComments';
+import type { UserLikes, UserLikesId } from './UserLikes';
 export interface JukeboxSessionAttributes {
     typeId: number;
     accessTypeId: number;
@@ -49,6 +52,17 @@ export declare class JukeboxSession extends Model<JukeboxSessionAttributes, Juke
     getJukeboxQueueMode: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueMode>;
     setJukeboxQueueMode: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueMode, JukeboxQueueModeId>;
     createJukeboxQueueMode: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueMode>;
+    guestUsers: GuestUser[];
+    getGuestUsers: Sequelize.HasManyGetAssociationsMixin<GuestUser>;
+    setGuestUsers: Sequelize.HasManySetAssociationsMixin<GuestUser, GuestUserId>;
+    addGuestUser: Sequelize.HasManyAddAssociationMixin<GuestUser, GuestUserId>;
+    addGuestUsers: Sequelize.HasManyAddAssociationsMixin<GuestUser, GuestUserId>;
+    createGuestUser: Sequelize.HasManyCreateAssociationMixin<GuestUser>;
+    removeGuestUser: Sequelize.HasManyRemoveAssociationMixin<GuestUser, GuestUserId>;
+    removeGuestUsers: Sequelize.HasManyRemoveAssociationsMixin<GuestUser, GuestUserId>;
+    hasGuestUser: Sequelize.HasManyHasAssociationMixin<GuestUser, GuestUserId>;
+    hasGuestUsers: Sequelize.HasManyHasAssociationsMixin<GuestUser, GuestUserId>;
+    countGuestUsers: Sequelize.HasManyCountAssociationsMixin;
     jukeboxCanonGenreRelations: JukeboxCanonGenreRelation[];
     getJukeboxCanonGenreRelations: Sequelize.HasManyGetAssociationsMixin<JukeboxCanonGenreRelation>;
     setJukeboxCanonGenreRelations: Sequelize.HasManySetAssociationsMixin<JukeboxCanonGenreRelation, JukeboxCanonGenreRelationId>;
@@ -104,6 +118,28 @@ export declare class JukeboxSession extends Model<JukeboxSessionAttributes, Juke
     hasNotification: Sequelize.HasManyHasAssociationMixin<Notification, NotificationId>;
     hasNotifications: Sequelize.HasManyHasAssociationsMixin<Notification, NotificationId>;
     countNotifications: Sequelize.HasManyCountAssociationsMixin;
+    userComments: UserComments[];
+    getUserComments: Sequelize.HasManyGetAssociationsMixin<UserComments>;
+    setUserComments: Sequelize.HasManySetAssociationsMixin<UserComments, UserCommentsId>;
+    addUserComment: Sequelize.HasManyAddAssociationMixin<UserComments, UserCommentsId>;
+    addUserComments: Sequelize.HasManyAddAssociationsMixin<UserComments, UserCommentsId>;
+    createUserComment: Sequelize.HasManyCreateAssociationMixin<UserComments>;
+    removeUserComment: Sequelize.HasManyRemoveAssociationMixin<UserComments, UserCommentsId>;
+    removeUserComments: Sequelize.HasManyRemoveAssociationsMixin<UserComments, UserCommentsId>;
+    hasUserComment: Sequelize.HasManyHasAssociationMixin<UserComments, UserCommentsId>;
+    hasUserComments: Sequelize.HasManyHasAssociationsMixin<UserComments, UserCommentsId>;
+    countUserComments: Sequelize.HasManyCountAssociationsMixin;
+    userLikes: UserLikes[];
+    getUserLikes: Sequelize.HasManyGetAssociationsMixin<UserLikes>;
+    setUserLikes: Sequelize.HasManySetAssociationsMixin<UserLikes, UserLikesId>;
+    addUserLike: Sequelize.HasManyAddAssociationMixin<UserLikes, UserLikesId>;
+    addUserLikes: Sequelize.HasManyAddAssociationsMixin<UserLikes, UserLikesId>;
+    createUserLike: Sequelize.HasManyCreateAssociationMixin<UserLikes>;
+    removeUserLike: Sequelize.HasManyRemoveAssociationMixin<UserLikes, UserLikesId>;
+    removeUserLikes: Sequelize.HasManyRemoveAssociationsMixin<UserLikes, UserLikesId>;
+    hasUserLike: Sequelize.HasManyHasAssociationMixin<UserLikes, UserLikesId>;
+    hasUserLikes: Sequelize.HasManyHasAssociationsMixin<UserLikes, UserLikesId>;
+    countUserLikes: Sequelize.HasManyCountAssociationsMixin;
     jukeboxStatus: JukeboxStatus;
     getJukeboxStatus: Sequelize.BelongsToGetAssociationMixin<JukeboxStatus>;
     setJukeboxStatus: Sequelize.BelongsToSetAssociationMixin<JukeboxStatus, JukeboxStatusId>;

package/dist/MerchItem.d.ts

@@ -0,0 +1,50 @@
+import * as Sequelize from 'sequelize';
+import { Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { MerchPlatform, MerchPlatformId } from './MerchPlatform';
+import type { MerchType, MerchTypeId } from './MerchType';
+export interface MerchItemAttributes {
+    canonArtistId: string;
+    merchTypeId: string;
+    merchPlatformId: string;
+    merchItemPlatformId: string;
+    title: string;
+    description: string;
+    photo?: string;
+    popularity?: number;
+    id: string;
+    inactive?: boolean;
+    createDate: Date;
+    updateDate: Date;
+}
+export type MerchItemPk = "id";
+export type MerchItemId = MerchItem[MerchItemPk];
+export type MerchItemOptionalAttributes = "photo" | "popularity" | "id" | "inactive" | "createDate" | "updateDate";
+export type MerchItemCreationAttributes = Optional<MerchItemAttributes, MerchItemOptionalAttributes>;
+export declare class MerchItem extends Model<MerchItemAttributes, MerchItemCreationAttributes> implements MerchItemAttributes {
+    canonArtistId: string;
+    merchTypeId: string;
+    merchPlatformId: string;
+    merchItemPlatformId: string;
+    title: string;
+    description: string;
+    photo?: string;
+    popularity?: number;
+    id: string;
+    inactive?: boolean;
+    createDate: Date;
+    updateDate: Date;
+    canonArtist: CanonArtist;
+    getCanonArtist: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+    setCanonArtist: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+    createCanonArtist: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+    merchPlatform: MerchPlatform;
+    getMerchPlatform: Sequelize.BelongsToGetAssociationMixin<MerchPlatform>;
+    setMerchPlatform: Sequelize.BelongsToSetAssociationMixin<MerchPlatform, MerchPlatformId>;
+    createMerchPlatform: Sequelize.BelongsToCreateAssociationMixin<MerchPlatform>;
+    merchType: MerchType;
+    getMerchType: Sequelize.BelongsToGetAssociationMixin<MerchType>;
+    setMerchType: Sequelize.BelongsToSetAssociationMixin<MerchType, MerchTypeId>;
+    createMerchType: Sequelize.BelongsToCreateAssociationMixin<MerchType>;
+    static initModel(sequelize: Sequelize.Sequelize): typeof MerchItem;
+}