@earbug/db-models 0.0.62 → 0.0.63

package/models/JukeboxCanonGenreRelation.ts

@@ -0,0 +1,108 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonGenre, CanonGenreId } from './CanonGenre';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxCanonGenreRelationAttributes {
+  id: string;
+  jukeboxSessionId: string;
+  canonGenreId: string;
+  stateId: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type JukeboxCanonGenreRelationPk = "id";
+export type JukeboxCanonGenreRelationId = JukeboxCanonGenreRelation[JukeboxCanonGenreRelationPk];
+export type JukeboxCanonGenreRelationOptionalAttributes = "id" | "createdAt" | "updatedAt";
+export type JukeboxCanonGenreRelationCreationAttributes = Optional<JukeboxCanonGenreRelationAttributes, JukeboxCanonGenreRelationOptionalAttributes>;
+
+export class JukeboxCanonGenreRelation extends Model<JukeboxCanonGenreRelationAttributes, JukeboxCanonGenreRelationCreationAttributes> implements JukeboxCanonGenreRelationAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  canonGenreId!: string;
+  stateId!: number;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // JukeboxCanonGenreRelation belongsTo CanonGenre via canonGenreId
+  canonGenre!: CanonGenre;
+  getCanonGenre!: Sequelize.BelongsToGetAssociationMixin<CanonGenre>;
+  setCanonGenre!: Sequelize.BelongsToSetAssociationMixin<CanonGenre, CanonGenreId>;
+  createCanonGenre!: Sequelize.BelongsToCreateAssociationMixin<CanonGenre>;
+  // JukeboxCanonGenreRelation belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxCanonGenreRelation {
+    return JukeboxCanonGenreRelation.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      unique: "unique_jukebox_canon_genre",
+      field: 'jukebox_session_id'
+    },
+    canonGenreId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_genre',
+        key: 'id'
+      },
+      unique: "unique_jukebox_canon_genre",
+      field: 'canon_genre_id'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      field: 'state_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_canon_genre_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_canon_genre_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "unique_jukebox_canon_genre",
+        unique: true,
+        fields: [
+          { name: "jukebox_session_id" },
+          { name: "canon_genre_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxInvite.ts

@@ -0,0 +1,125 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxInviteAttributes {
+  id: string;
+  jukeboxSessionId: string;
+  inviterUserId: string;
+  invitedUserId?: string;
+  email?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type JukeboxInvitePk = "id";
+export type JukeboxInviteId = JukeboxInvite[JukeboxInvitePk];
+export type JukeboxInviteOptionalAttributes = "id" | "invitedUserId" | "email" | "createdAt" | "updatedAt";
+export type JukeboxInviteCreationAttributes = Optional<JukeboxInviteAttributes, JukeboxInviteOptionalAttributes>;
+
+export class JukeboxInvite extends Model<JukeboxInviteAttributes, JukeboxInviteCreationAttributes> implements JukeboxInviteAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  inviterUserId!: string;
+  invitedUserId?: string;
+  email?: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // JukeboxInvite belongsTo AppUser via invitedUserId
+  invitedUser!: AppUser;
+  getInvitedUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setInvitedUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createInvitedUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxInvite belongsTo AppUser via inviterUserId
+  inviterUser!: AppUser;
+  getInviterUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setInviterUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createInviterUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxInvite belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxInvite {
+    return JukeboxInvite.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
+    inviterUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'inviter_user_id'
+    },
+    invitedUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'invited_user_id'
+    },
+    email: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_invite',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_jukebox_invite_invited_user",
+        fields: [
+          { name: "invited_user_id" },
+        ]
+      },
+      {
+        name: "idx_jukebox_invite_session",
+        fields: [
+          { name: "jukebox_session_id" },
+        ]
+      },
+      {
+        name: "jukebox_invite_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxQueueEntry.ts

@@ -0,0 +1,247 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 {
+  id: string;
+  jukeboxSessionId: string;
+  trackId?: string;
+  playbackPriority?: number;
+  trackAddedUserId?: string;
+  createdAt: Date;
+  updatedAt: Date;
+  setOrder: number;
+  trackDeletionReasonId: number;
+  playbackStatusTypeId: number;
+  playbackStarted?: Date;
+  trackThumbsUp?: string[];
+  trackThumbsDown?: string[];
+  platformTrackId?: string;
+  trackAddedGuestUserId?: string;
+}
+
+export type JukeboxQueueEntryPk = "id";
+export type JukeboxQueueEntryId = JukeboxQueueEntry[JukeboxQueueEntryPk];
+export type JukeboxQueueEntryOptionalAttributes = "id" | "trackId" | "playbackPriority" | "trackAddedUserId" | "createdAt" | "updatedAt" | "setOrder" | "trackDeletionReasonId" | "playbackStatusTypeId" | "playbackStarted" | "trackThumbsUp" | "trackThumbsDown" | "platformTrackId" | "trackAddedGuestUserId";
+export type JukeboxQueueEntryCreationAttributes = Optional<JukeboxQueueEntryAttributes, JukeboxQueueEntryOptionalAttributes>;
+
+export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, JukeboxQueueEntryCreationAttributes> implements JukeboxQueueEntryAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  trackId?: string;
+  playbackPriority?: number;
+  trackAddedUserId?: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  setOrder!: number;
+  trackDeletionReasonId!: number;
+  playbackStatusTypeId!: number;
+  playbackStarted?: Date;
+  trackThumbsUp?: string[];
+  trackThumbsDown?: string[];
+  platformTrackId?: string;
+  trackAddedGuestUserId?: string;
+
+  // JukeboxQueueEntry belongsTo AppUser via trackAddedUserId
+  trackAddedUser!: AppUser;
+  getTrackAddedUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setTrackAddedUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createTrackAddedUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxQueueEntry belongsTo CanonTrack via trackId
+  track!: CanonTrack;
+  getTrack!: Sequelize.BelongsToGetAssociationMixin<CanonTrack>;
+  setTrack!: Sequelize.BelongsToSetAssociationMixin<CanonTrack, CanonTrackId>;
+  createTrack!: Sequelize.BelongsToCreateAssociationMixin<CanonTrack>;
+  // JukeboxQueueEntry belongsTo GuestUser via trackAddedGuestUserId
+  trackAddedGuestUser!: GuestUser;
+  getTrackAddedGuestUser!: Sequelize.BelongsToGetAssociationMixin<GuestUser>;
+  setTrackAddedGuestUser!: Sequelize.BelongsToSetAssociationMixin<GuestUser, GuestUserId>;
+  createTrackAddedGuestUser!: Sequelize.BelongsToCreateAssociationMixin<GuestUser>;
+  // JukeboxQueueEntry hasMany JukeboxUser via pausedQueueEntryId
+  jukeboxUsers!: JukeboxUser[];
+  getJukeboxUsers!: Sequelize.HasManyGetAssociationsMixin<JukeboxUser>;
+  setJukeboxUsers!: Sequelize.HasManySetAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  addJukeboxUser!: Sequelize.HasManyAddAssociationMixin<JukeboxUser, JukeboxUserId>;
+  addJukeboxUsers!: Sequelize.HasManyAddAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  createJukeboxUser!: Sequelize.HasManyCreateAssociationMixin<JukeboxUser>;
+  removeJukeboxUser!: Sequelize.HasManyRemoveAssociationMixin<JukeboxUser, JukeboxUserId>;
+  removeJukeboxUsers!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  hasJukeboxUser!: Sequelize.HasManyHasAssociationMixin<JukeboxUser, JukeboxUserId>;
+  hasJukeboxUsers!: Sequelize.HasManyHasAssociationsMixin<JukeboxUser, JukeboxUserId>;
+  countJukeboxUsers!: Sequelize.HasManyCountAssociationsMixin;
+  // JukeboxQueueEntry belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // JukeboxQueueEntry belongsTo PlatformTrack via platformTrackId
+  platformTrack!: PlatformTrack;
+  getPlatformTrack!: Sequelize.BelongsToGetAssociationMixin<PlatformTrack>;
+  setPlatformTrack!: Sequelize.BelongsToSetAssociationMixin<PlatformTrack, PlatformTrackId>;
+  createPlatformTrack!: Sequelize.BelongsToCreateAssociationMixin<PlatformTrack>;
+  // JukeboxQueueEntry belongsTo PlaybackStatusType via playbackStatusTypeId
+  playbackStatusType!: PlaybackStatusType;
+  getPlaybackStatusType!: Sequelize.BelongsToGetAssociationMixin<PlaybackStatusType>;
+  setPlaybackStatusType!: Sequelize.BelongsToSetAssociationMixin<PlaybackStatusType, PlaybackStatusTypeId>;
+  createPlaybackStatusType!: Sequelize.BelongsToCreateAssociationMixin<PlaybackStatusType>;
+  // JukeboxQueueEntry belongsTo TrackDeletionReason via trackDeletionReasonId
+  trackDeletionReason!: TrackDeletionReason;
+  getTrackDeletionReason!: Sequelize.BelongsToGetAssociationMixin<TrackDeletionReason>;
+  setTrackDeletionReason!: Sequelize.BelongsToSetAssociationMixin<TrackDeletionReason, TrackDeletionReasonId>;
+  createTrackDeletionReason!: Sequelize.BelongsToCreateAssociationMixin<TrackDeletionReason>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxQueueEntry {
+    return JukeboxQueueEntry.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
+    trackId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'track_id'
+    },
+    playbackPriority: {
+      type: DataTypes.DECIMAL,
+      allowNull: true,
+      field: 'playback_priority'
+    },
+    trackAddedUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'track_added_user_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    },
+    setOrder: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      defaultValue: 1,
+      field: 'set_order'
+    },
+    trackDeletionReasonId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'track_deletion_reason',
+        key: 'id'
+      },
+      field: 'track_deletion_reason_id'
+    },
+    playbackStatusTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'playback_status_type',
+        key: 'id'
+      },
+      field: 'playback_status_type_id'
+    },
+    playbackStarted: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'playback_started'
+    },
+    trackThumbsUp: {
+      type: DataTypes.ARRAY(DataTypes.UUID),
+      allowNull: true,
+      defaultValue: ["ARRAY[]"],
+      field: 'track_thumbs_up'
+    },
+    trackThumbsDown: {
+      type: DataTypes.ARRAY(DataTypes.UUID),
+      allowNull: true,
+      defaultValue: ["ARRAY[]"],
+      field: 'track_thumbs_down'
+    },
+    platformTrackId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'platform_track',
+        key: 'id'
+      },
+      field: 'platform_track_id'
+    },
+    trackAddedGuestUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'guest_user',
+        key: 'id'
+      },
+      field: 'track_added_guest_user_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_queue_entry',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_jukebox_queue_entry_platform_track",
+        fields: [
+          { name: "platform_track_id" },
+        ]
+      },
+      {
+        name: "idx_jukebox_queue_entry_session",
+        fields: [
+          { name: "jukebox_session_id" },
+        ]
+      },
+      {
+        name: "idx_jukebox_queue_entry_track",
+        fields: [
+          { name: "track_id" },
+        ]
+      },
+      {
+        name: "jukebox_queue_entry_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxQueueMode.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxQueueModeAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxQueueModePk = "id";
+export type JukeboxQueueModeId = JukeboxQueueMode[JukeboxQueueModePk];
+export type JukeboxQueueModeCreationAttributes = JukeboxQueueModeAttributes;
+
+export class JukeboxQueueMode extends Model<JukeboxQueueModeAttributes, JukeboxQueueModeCreationAttributes> implements JukeboxQueueModeAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxQueueMode hasMany JukeboxSession via jukeboxQueueModeId
+  jukeboxSessions!: JukeboxSession[];
+  getJukeboxSessions!: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+  setJukeboxSessions!: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSession!: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSessions!: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+  removeJukeboxSession!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  removeJukeboxSessions!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSession!: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSessions!: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  countJukeboxSessions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxQueueMode {
+    return JukeboxQueueMode.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_queue_mode',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_queue_mode_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}