@earbug/db-models 0.0.6 → 0.0.8

package/models/PlatformUserPlaylistTrack.ts

@@ -5,36 +5,36 @@ import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUse
 import type { State, StateId } from './State';
 
 export interface PlatformUserPlaylistTrackAttributes {
-  id: string;
   platformTrackId: string;
   platformUserPlaylistId: string;
-  trackPosition: number;
   addedDate?: Date;
   addedByPlatformUserId?: string;
+  externalPlaylistTrackId: string;
+  id: string;
+  trackPosition: number;
   isLocal: boolean;
   createDate: Date;
   updateDate: Date;
   stateId: number;
-  externalPlaylistTrackId: string;
 }
 
 export type PlatformUserPlaylistTrackPk = "id";
 export type PlatformUserPlaylistTrackId = PlatformUserPlaylistTrack[PlatformUserPlaylistTrackPk];
-export type PlatformUserPlaylistTrackOptionalAttributes = "id" | "trackPosition" | "addedDate" | "addedByPlatformUserId" | "createDate" | "updateDate" | "stateId";
+export type PlatformUserPlaylistTrackOptionalAttributes = "addedDate" | "addedByPlatformUserId" | "id" | "trackPosition" | "createDate" | "updateDate" | "stateId";
 export type PlatformUserPlaylistTrackCreationAttributes = Optional<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackOptionalAttributes>;
 
 export class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAttributes, PlatformUserPlaylistTrackCreationAttributes> implements PlatformUserPlaylistTrackAttributes {
-  id!: string;
   platformTrackId!: string;
   platformUserPlaylistId!: string;
-  trackPosition!: number;
   addedDate?: Date;
   addedByPlatformUserId?: string;
+  externalPlaylistTrackId!: string;
+  id!: string;
+  trackPosition!: number;
   isLocal!: boolean;
   createDate!: Date;
   updateDate!: Date;
   stateId!: number;
-  externalPlaylistTrackId!: string;
 
   // PlatformUserPlaylistTrack belongsTo PlatformTrack via platformTrackId
   platformTrack!: PlatformTrack;
@@ -54,12 +54,6 @@ export class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAt
 
   static initModel(sequelize: Sequelize.Sequelize): typeof PlatformUserPlaylistTrack {
     return PlatformUserPlaylistTrack.init({
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
-      primaryKey: true
-    },
     platformTrackId: {
       type: DataTypes.UUID,
       allowNull: false,
@@ -80,12 +74,6 @@ export class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAt
       unique: "uk_playlist_id_track_id",
       field: 'platform_user_playlist_id'
     },
-    trackPosition: {
-      type: DataTypes.INTEGER,
-      allowNull: false,
-      defaultValue: 0,
-      field: 'track_position'
-    },
     addedDate: {
       type: DataTypes.DATE,
       allowNull: true,
@@ -96,6 +84,23 @@ export class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAt
       allowNull: true,
       field: 'added_by_platform_user_id'
     },
+    externalPlaylistTrackId: {
+      type: DataTypes.STRING(255),
+      allowNull: false,
+      field: 'external_playlist_track_id'
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    trackPosition: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'track_position'
+    },
     isLocal: {
       type: DataTypes.BOOLEAN,
       allowNull: false,
@@ -123,11 +128,6 @@ export class PlatformUserPlaylistTrack extends Model<PlatformUserPlaylistTrackAt
         key: 'id'
       },
       field: 'state_id'
-    },
-    externalPlaylistTrackId: {
-      type: DataTypes.STRING(255),
-      allowNull: false,
-      field: 'external_playlist_track_id'
     }
   }, {
     sequelize,

package/models/PlaybackStatus.ts

@@ -1,10 +1,9 @@
 import * as Sequelize from 'sequelize';
 import { DataTypes, Model, Optional } from 'sequelize';
-import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 
 export interface PlaybackStatusAttributes {
-  id: number;
   description: string;
+  id: number;
 }
 
 export type PlaybackStatusPk = "id";
@@ -12,34 +11,22 @@ export type PlaybackStatusId = PlaybackStatus[PlaybackStatusPk];
 export type PlaybackStatusCreationAttributes = PlaybackStatusAttributes;
 
 export class PlaybackStatus extends Model<PlaybackStatusAttributes, PlaybackStatusCreationAttributes> implements PlaybackStatusAttributes {
-  id!: number;
   description!: string;
+  id!: number;
 
-  // PlaybackStatus hasMany JukeboxQueueEntry via playbackStatusTypeId
-  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;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof PlaybackStatus {
     return PlaybackStatus.init({
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
     id: {
       autoIncrement: true,
       autoIncrementIdentity: true,
       type: DataTypes.SMALLINT,
       allowNull: false,
       primaryKey: true
-    },
-    description: {
-      type: DataTypes.TEXT,
-      allowNull: false
     }
   }, {
     sequelize,

package/models/PlaybackStatusType.ts

@@ -1,5 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
 
 export interface PlaybackStatusTypeAttributes {
   id: number;
@@ -14,6 +15,18 @@ export class PlaybackStatusType extends Model<PlaybackStatusTypeAttributes, Play
   id!: number;
   description!: string;
 
+  // PlaybackStatusType hasMany JukeboxQueueEntry via playbackStatusTypeId
+  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;
 
   static initModel(sequelize: Sequelize.Sequelize): typeof PlaybackStatusType {
     return PlaybackStatusType.init({

package/models/State.ts

@@ -5,8 +5,8 @@ import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUse
 import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
 
 export interface StateAttributes {
-  id: number;
   description: string;
+  id: number;
 }
 
 export type StatePk = "id";
@@ -14,8 +14,8 @@ export type StateId = State[StatePk];
 export type StateCreationAttributes = StateAttributes;
 
 export class State extends Model<StateAttributes, StateCreationAttributes> implements StateAttributes {
-  id!: number;
   description!: string;
+  id!: number;
 
   // State hasMany AppUser via stateId
   appUsers!: AppUser[];
@@ -56,16 +56,16 @@ export class State extends Model<StateAttributes, StateCreationAttributes> imple
 
   static initModel(sequelize: Sequelize.Sequelize): typeof State {
     return State.init({
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
     id: {
       autoIncrement: true,
       autoIncrementIdentity: true,
       type: DataTypes.SMALLINT,
       allowNull: false,
       primaryKey: true
-    },
-    description: {
-      type: DataTypes.TEXT,
-      allowNull: false
     }
   }, {
     sequelize,

package/models/UnmatchedAlbum.ts

@@ -3,8 +3,8 @@ import { DataTypes, Model, Optional } from 'sequelize';
 import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
 
 export interface UnmatchedAlbumAttributes {
-  id: string;
   platformAlbumId: string;
+  id: string;
   createDate: Date;
 }
 
@@ -14,8 +14,8 @@ export type UnmatchedAlbumOptionalAttributes = "id" | "createDate";
 export type UnmatchedAlbumCreationAttributes = Optional<UnmatchedAlbumAttributes, UnmatchedAlbumOptionalAttributes>;
 
 export class UnmatchedAlbum extends Model<UnmatchedAlbumAttributes, UnmatchedAlbumCreationAttributes> implements UnmatchedAlbumAttributes {
-  id!: string;
   platformAlbumId!: string;
+  id!: string;
   createDate!: Date;
 
   // UnmatchedAlbum belongsTo PlatformAlbum via platformAlbumId
@@ -26,12 +26,6 @@ export class UnmatchedAlbum extends Model<UnmatchedAlbumAttributes, UnmatchedAlb
 
   static initModel(sequelize: Sequelize.Sequelize): typeof UnmatchedAlbum {
     return UnmatchedAlbum.init({
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
-      primaryKey: true
-    },
     platformAlbumId: {
       type: DataTypes.UUID,
       allowNull: false,
@@ -41,6 +35,12 @@ export class UnmatchedAlbum extends Model<UnmatchedAlbumAttributes, UnmatchedAlb
       },
       field: 'platform_album_id'
     },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
     createDate: {
       type: DataTypes.DATE,
       allowNull: false,

package/models/UnmatchedArtist.ts

@@ -3,9 +3,9 @@ import { DataTypes, Model, Optional } from 'sequelize';
 import type { Platform, PlatformId } from './Platform';
 
 export interface UnmatchedArtistAttributes {
-  id: string;
   platformId: number;
   externalArtistId: number;
+  id: string;
   createDate: Date;
   updateDate: Date;
 }
@@ -16,9 +16,9 @@ export type UnmatchedArtistOptionalAttributes = "id" | "createDate" | "updateDat
 export type UnmatchedArtistCreationAttributes = Optional<UnmatchedArtistAttributes, UnmatchedArtistOptionalAttributes>;
 
 export class UnmatchedArtist extends Model<UnmatchedArtistAttributes, UnmatchedArtistCreationAttributes> implements UnmatchedArtistAttributes {
-  id!: string;
   platformId!: number;
   externalArtistId!: number;
+  id!: string;
   createDate!: Date;
   updateDate!: Date;
 
@@ -30,12 +30,6 @@ export class UnmatchedArtist extends Model<UnmatchedArtistAttributes, UnmatchedA
 
   static initModel(sequelize: Sequelize.Sequelize): typeof UnmatchedArtist {
     return UnmatchedArtist.init({
-    id: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
-      primaryKey: true
-    },
     platformId: {
       type: DataTypes.SMALLINT,
       allowNull: false,
@@ -50,6 +44,12 @@ export class UnmatchedArtist extends Model<UnmatchedArtistAttributes, UnmatchedA
       allowNull: false,
       field: 'external_artist_id'
     },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
     createDate: {
       type: DataTypes.DATE,
       allowNull: false,

package/models/UserContacts.ts

@@ -4,7 +4,6 @@ import type { AppUser, AppUserId } from './AppUser';
 
 export interface UserContactsAttributes {
   appUserId: string;
-  contactId: string;
   contactAppUserId?: string;
   firstName?: string;
   lastName?: string;
@@ -18,16 +17,16 @@ export interface UserContactsAttributes {
   contactPhone3?: string;
   contactPhone3Type?: "mobile" | "work" | "home" | "main";
   active?: boolean;
+  contactId: string;
 }
 
 export type UserContactsPk = "contactId";
 export type UserContactsId = UserContacts[UserContactsPk];
-export type UserContactsOptionalAttributes = "contactId" | "contactAppUserId" | "firstName" | "lastName" | "contactEmail1" | "contactEmail2" | "contactEmail3" | "contactPhone1" | "contactPhone1Type" | "contactPhone2" | "contactPhone2Type" | "contactPhone3" | "contactPhone3Type" | "active";
+export type UserContactsOptionalAttributes = "contactAppUserId" | "firstName" | "lastName" | "contactEmail1" | "contactEmail2" | "contactEmail3" | "contactPhone1" | "contactPhone1Type" | "contactPhone2" | "contactPhone2Type" | "contactPhone3" | "contactPhone3Type" | "active" | "contactId";
 export type UserContactsCreationAttributes = Optional<UserContactsAttributes, UserContactsOptionalAttributes>;
 
 export class UserContacts extends Model<UserContactsAttributes, UserContactsCreationAttributes> implements UserContactsAttributes {
   appUserId!: string;
-  contactId!: string;
   contactAppUserId?: string;
   firstName?: string;
   lastName?: string;
@@ -41,6 +40,7 @@ export class UserContacts extends Model<UserContactsAttributes, UserContactsCrea
   contactPhone3?: string;
   contactPhone3Type?: "mobile" | "work" | "home" | "main";
   active?: boolean;
+  contactId!: string;
 
   // UserContacts belongsTo AppUser via appUserId
   appUser!: AppUser;
@@ -59,13 +59,6 @@ export class UserContacts extends Model<UserContactsAttributes, UserContactsCrea
       },
       field: 'app_user_id'
     },
-    contactId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      defaultValue: DataTypes.UUIDV4,
-      primaryKey: true,
-      field: 'contact_id'
-    },
     contactAppUserId: {
       type: DataTypes.UUID,
       allowNull: true,
@@ -129,6 +122,13 @@ export class UserContacts extends Model<UserContactsAttributes, UserContactsCrea
     active: {
       type: DataTypes.BOOLEAN,
       allowNull: true
+    },
+    contactId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true,
+      field: 'contact_id'
     }
   }, {
     sequelize,

package/models/init-models.ts

@@ -422,9 +422,10 @@ export function initModels(sequelize: Sequelize) {
   const UnmatchedArtist = _UnmatchedArtist.initModel(sequelize);
   const UserContacts = _UserContacts.initModel(sequelize);
 
+  CanonAlbum.belongsToMany(CanonTrack, { as: 'canonTrackIdCanonTracks', through: CanonAlbumTrackRelation, foreignKey: "canonAlbumId", otherKey: "canonTrackId" });
   CanonAlbum.belongsToMany(ExternalReference, { as: 'externalReferenceIdExternalReferences', through: CanonAlbumExternalReferenceRelation, foreignKey: "canonAlbumId", otherKey: "externalReferenceId" });
   CanonAlbum.belongsToMany(PlatformAlbum, { as: 'platformAlbumIdPlatformAlbums', through: CanonToPlatformAlbumRelation, foreignKey: "canonAlbumId", otherKey: "platformAlbumId" });
-  CanonArtist.belongsToMany(CanonTrack, { as: 'canonTrackIdCanonTracks', through: CanonArtistTrackRelation, foreignKey: "canonArtistId", otherKey: "canonTrackId" });
+  CanonArtist.belongsToMany(CanonTrack, { as: 'canonTrackIdCanonTrackCanonArtistTrackRelations', through: CanonArtistTrackRelation, foreignKey: "canonArtistId", otherKey: "canonTrackId" });
   CanonArtist.belongsToMany(PlatformAlbum, { as: 'canonAlbumIdPlatformAlbumCanonArtistAlbumRelations', through: CanonArtistAlbumRelation, foreignKey: "canonArtistId", otherKey: "canonAlbumId" });
   CanonArtist.belongsToMany(PlatformArtist, { as: 'platformArtistIdPlatformArtists', through: CanonToPlatformArtistRelation, foreignKey: "canonArtistId", otherKey: "platformArtistId" });
   CanonGenre.belongsToMany(ExternalReference, { as: 'externalReferenceIdExternalReferenceCanonGenreExternalReferenceRelations', through: CanonGenreExternalReferenceRelation, foreignKey: "canonGenreId", otherKey: "externalReferenceId" });
@@ -435,6 +436,7 @@ export function initModels(sequelize: Sequelize) {
   CanonLabel.belongsToMany(PlatformAlbum, { as: 'canonAlbumIdPlatformAlbumCanonAlbumLabelRelations', through: CanonAlbumLabelRelation, foreignKey: "canonLabelId", otherKey: "canonAlbumId" });
   CanonMember.belongsToMany(ExternalReference, { as: 'externalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations', through: CanonMemberExternalReferenceRelation, foreignKey: "canonMemberId", otherKey: "externalReferenceId" });
   CanonMember.belongsToMany(PlatformArtist, { as: 'canonArtistIdPlatformArtistCanonArtistMemberRelations', through: CanonArtistMemberRelation, foreignKey: "canonMemberId", otherKey: "canonArtistId" });
+  CanonTrack.belongsToMany(CanonAlbum, { as: 'canonAlbumIdCanonAlbumCanonAlbumTrackRelations', through: CanonAlbumTrackRelation, foreignKey: "canonTrackId", otherKey: "canonAlbumId" });
   CanonTrack.belongsToMany(CanonArtist, { as: 'canonArtistIdCanonArtistCanonArtistTrackRelations', through: CanonArtistTrackRelation, foreignKey: "canonTrackId", otherKey: "canonArtistId" });
   CanonTrack.belongsToMany(PlatformTrack, { as: 'platformTrackIdPlatformTracks', through: CanonToPlatformTrackRelation, foreignKey: "canonTrackId", otherKey: "platformTrackId" });
   ExternalReference.belongsToMany(CanonAlbum, { as: 'canonAlbumIdCanonAlbums', through: CanonAlbumExternalReferenceRelation, foreignKey: "externalReferenceId", otherKey: "canonAlbumId" });
@@ -448,7 +450,6 @@ export function initModels(sequelize: Sequelize) {
   PlatformAlbum.belongsToMany(CanonLabel, { as: 'canonLabelIdCanonLabels', through: CanonAlbumLabelRelation, foreignKey: "canonAlbumId", otherKey: "canonLabelId" });
   PlatformAlbum.belongsToMany(PlatformArtist, { as: 'platformArtistIdPlatformArtistPlatformArtistAlbumRelations', through: PlatformArtistAlbumRelation, foreignKey: "platformAlbumId", otherKey: "platformArtistId" });
   PlatformAlbum.belongsToMany(PlatformGenre, { as: 'platformGenreIdPlatformGenrePlatformAlbumGenreRelations', through: PlatformAlbumGenreRelation, foreignKey: "platformAlbumId", otherKey: "platformGenreId" });
-  PlatformAlbum.belongsToMany(PlatformTrack, { as: 'canonTrackIdPlatformTracks', through: CanonAlbumTrackRelation, foreignKey: "canonAlbumId", otherKey: "canonTrackId" });
   PlatformAlbum.belongsToMany(PlatformTrack, { as: 'platformTrackIdPlatformTrackPlatformAlbumTrackRelations', through: PlatformAlbumTrackRelation, foreignKey: "platformAlbumId", otherKey: "platformTrackId" });
   PlatformArtist.belongsToMany(CanonArtist, { as: 'canonArtistIdCanonArtistCanonToPlatformArtistRelations', through: CanonToPlatformArtistRelation, foreignKey: "platformArtistId", otherKey: "canonArtistId" });
   PlatformArtist.belongsToMany(CanonGenre, { as: 'canonGenreIdCanonGenreCanonArtistGenreRelations', through: CanonArtistGenreRelation, foreignKey: "canonArtistId", otherKey: "canonGenreId" });
@@ -462,7 +463,6 @@ export function initModels(sequelize: Sequelize) {
   PlatformGenre.belongsToMany(PlatformArtist, { as: 'platformArtistIdPlatformArtistPlatformArtistGenreRelations', through: PlatformArtistGenreRelation, foreignKey: "platformGenreId", otherKey: "platformArtistId" });
   PlatformGenre.belongsToMany(PlatformTrack, { as: 'platformTrackIdPlatformTrackPlatformTrackGenreRelations', through: PlatformTrackGenreRelation, foreignKey: "platformGenreId", otherKey: "platformTrackId" });
   PlatformTrack.belongsToMany(CanonTrack, { as: 'canonTrackIdCanonTrackCanonToPlatformTrackRelations', through: CanonToPlatformTrackRelation, foreignKey: "platformTrackId", otherKey: "canonTrackId" });
-  PlatformTrack.belongsToMany(PlatformAlbum, { as: 'canonAlbumIdPlatformAlbumCanonAlbumTrackRelations', through: CanonAlbumTrackRelation, foreignKey: "canonTrackId", otherKey: "canonAlbumId" });
   PlatformTrack.belongsToMany(PlatformAlbum, { as: 'platformAlbumIdPlatformAlbumPlatformAlbumTrackRelations', through: PlatformAlbumTrackRelation, foreignKey: "platformTrackId", otherKey: "platformAlbumId" });
   PlatformTrack.belongsToMany(PlatformArtist, { as: 'platformArtistIdPlatformArtistPlatformArtistTrackRelations', through: PlatformArtistTrackRelation, foreignKey: "platformTrackId", otherKey: "platformArtistId" });
   PlatformTrack.belongsToMany(PlatformGenre, { as: 'platformGenreIdPlatformGenrePlatformTrackGenreRelations', through: PlatformTrackGenreRelation, foreignKey: "platformTrackId", otherKey: "platformGenreId" });
@@ -492,6 +492,8 @@ export function initModels(sequelize: Sequelize) {
   CanonAlbum.hasMany(CanonAlbumExternalReferenceRelation, { as: "canonAlbumExternalReferenceRelations", foreignKey: "canonAlbumId"});
   CanonAlbumImageHarvested.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId"});
   CanonAlbum.hasMany(CanonAlbumImageHarvested, { as: "canonAlbumImageHarvesteds", foreignKey: "canonAlbumId"});
+  CanonAlbumTrackRelation.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId"});
+  CanonAlbum.hasMany(CanonAlbumTrackRelation, { as: "canonAlbumTrackRelations", foreignKey: "canonAlbumId"});
   CanonToPlatformAlbumRelation.belongsTo(CanonAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId"});
   CanonAlbum.hasMany(CanonToPlatformAlbumRelation, { as: "canonToPlatformAlbumRelations", foreignKey: "canonAlbumId"});
   CanonArtistAlbumRelation.belongsTo(CanonArtist, { as: "canonArtist", foreignKey: "canonArtistId"});
@@ -520,6 +522,8 @@ export function initModels(sequelize: Sequelize) {
   CanonMember.hasMany(CanonArtistMemberRelation, { as: "canonArtistMemberRelations", foreignKey: "canonMemberId"});
   CanonMemberExternalReferenceRelation.belongsTo(CanonMember, { as: "canonMember", foreignKey: "canonMemberId"});
   CanonMember.hasMany(CanonMemberExternalReferenceRelation, { as: "canonMemberExternalReferenceRelations", foreignKey: "canonMemberId"});
+  CanonAlbumTrackRelation.belongsTo(CanonTrack, { as: "canonTrack", foreignKey: "canonTrackId"});
+  CanonTrack.hasMany(CanonAlbumTrackRelation, { as: "canonAlbumTrackRelations", foreignKey: "canonTrackId"});
   CanonArtistTrackRelation.belongsTo(CanonTrack, { as: "canonTrack", foreignKey: "canonTrackId"});
   CanonTrack.hasMany(CanonArtistTrackRelation, { as: "canonArtistTrackRelations", foreignKey: "canonTrackId"});
   CanonToPlatformTrackRelation.belongsTo(CanonTrack, { as: "canonTrack", foreignKey: "canonTrackId"});
@@ -582,8 +586,6 @@ export function initModels(sequelize: Sequelize) {
   PlatformAlbum.hasMany(CanonAlbumGenreRelation, { as: "canonAlbumGenreRelations", foreignKey: "canonAlbumId"});
   CanonAlbumLabelRelation.belongsTo(PlatformAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId"});
   PlatformAlbum.hasMany(CanonAlbumLabelRelation, { as: "canonAlbumLabelRelations", foreignKey: "canonAlbumId"});
-  CanonAlbumTrackRelation.belongsTo(PlatformAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId"});
-  PlatformAlbum.hasMany(CanonAlbumTrackRelation, { as: "canonAlbumTrackRelations", foreignKey: "canonAlbumId"});
   CanonArtistAlbumRelation.belongsTo(PlatformAlbum, { as: "canonAlbum", foreignKey: "canonAlbumId"});
   PlatformAlbum.hasMany(CanonArtistAlbumRelation, { as: "canonArtistAlbumRelations", foreignKey: "canonAlbumId"});
   CanonToPlatformAlbumRelation.belongsTo(PlatformAlbum, { as: "platformAlbum", foreignKey: "platformAlbumId"});
@@ -620,8 +622,6 @@ export function initModels(sequelize: Sequelize) {
   PlatformGenre.hasMany(PlatformArtistGenreRelation, { as: "platformArtistGenreRelations", foreignKey: "platformGenreId"});
   PlatformTrackGenreRelation.belongsTo(PlatformGenre, { as: "platformGenre", foreignKey: "platformGenreId"});
   PlatformGenre.hasMany(PlatformTrackGenreRelation, { as: "platformTrackGenreRelations", foreignKey: "platformGenreId"});
-  CanonAlbumTrackRelation.belongsTo(PlatformTrack, { as: "canonTrack", foreignKey: "canonTrackId"});
-  PlatformTrack.hasMany(CanonAlbumTrackRelation, { as: "canonAlbumTrackRelations", foreignKey: "canonTrackId"});
   CanonToPlatformTrackRelation.belongsTo(PlatformTrack, { as: "platformTrack", foreignKey: "platformTrackId"});
   PlatformTrack.hasMany(CanonToPlatformTrackRelation, { as: "canonToPlatformTrackRelations", foreignKey: "platformTrackId"});
   PlatformAlbumTrackRelation.belongsTo(PlatformTrack, { as: "platformTrack", foreignKey: "platformTrackId"});
@@ -638,8 +638,8 @@ export function initModels(sequelize: Sequelize) {
   PlatformUserAlbum.hasMany(PlatformUserAlbumTrack, { as: "platformUserAlbumTracks", foreignKey: "platformUserAlbumId"});
   PlatformUserPlaylistTrack.belongsTo(PlatformUserPlaylist, { as: "platformUserPlaylist", foreignKey: "platformUserPlaylistId"});
   PlatformUserPlaylist.hasMany(PlatformUserPlaylistTrack, { as: "platformUserPlaylistTracks", foreignKey: "platformUserPlaylistId"});
-  JukeboxQueueEntry.belongsTo(PlaybackStatus, { as: "playbackStatusType", foreignKey: "playbackStatusTypeId"});
-  PlaybackStatus.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "playbackStatusTypeId"});
+  JukeboxQueueEntry.belongsTo(PlaybackStatusType, { as: "playbackStatusType", foreignKey: "playbackStatusTypeId"});
+  PlaybackStatusType.hasMany(JukeboxQueueEntry, { as: "jukeboxQueueEntries", foreignKey: "playbackStatusTypeId"});
   AppUser.belongsTo(State, { as: "state", foreignKey: "stateId"});
   State.hasMany(AppUser, { as: "appUsers", foreignKey: "stateId"});
   PlatformUserPlaylist.belongsTo(State, { as: "state", foreignKey: "stateId"});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@earbug/db-models",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "main": "dist/init-models.js",
   "types": "dist/init-models.d.ts",
   "scripts": {