@earbug/db-models 0.0.1

package/models/State.ts

@@ -0,0 +1,86 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId } from './PlatformUserPlaylistTrack';
+
+export interface StateAttributes {
+  id: number;
+  description: string;
+}
+
+export type StatePk = "id";
+export type StateId = State[StatePk];
+export type StateCreationAttributes = StateAttributes;
+
+export class State extends Model<StateAttributes, StateCreationAttributes> implements StateAttributes {
+  id!: number;
+  description!: string;
+
+  // State hasMany AppUser via stateId
+  appUsers!: AppUser[];
+  getAppUsers!: Sequelize.HasManyGetAssociationsMixin<AppUser>;
+  setAppUsers!: Sequelize.HasManySetAssociationsMixin<AppUser, AppUserId>;
+  addAppUser!: Sequelize.HasManyAddAssociationMixin<AppUser, AppUserId>;
+  addAppUsers!: Sequelize.HasManyAddAssociationsMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.HasManyCreateAssociationMixin<AppUser>;
+  removeAppUser!: Sequelize.HasManyRemoveAssociationMixin<AppUser, AppUserId>;
+  removeAppUsers!: Sequelize.HasManyRemoveAssociationsMixin<AppUser, AppUserId>;
+  hasAppUser!: Sequelize.HasManyHasAssociationMixin<AppUser, AppUserId>;
+  hasAppUsers!: Sequelize.HasManyHasAssociationsMixin<AppUser, AppUserId>;
+  countAppUsers!: Sequelize.HasManyCountAssociationsMixin;
+  // State hasMany PlatformUserPlaylist via stateId
+  platformUserPlaylists!: PlatformUserPlaylist[];
+  getPlatformUserPlaylists!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylist>;
+  setPlatformUserPlaylists!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  addPlatformUserPlaylist!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  addPlatformUserPlaylists!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  createPlatformUserPlaylist!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylist>;
+  removePlatformUserPlaylist!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  removePlatformUserPlaylists!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  hasPlatformUserPlaylist!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  hasPlatformUserPlaylists!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylist, PlatformUserPlaylistId>;
+  countPlatformUserPlaylists!: Sequelize.HasManyCountAssociationsMixin;
+  // State hasMany PlatformUserPlaylistTrack via stateId
+  platformUserPlaylistTracks!: PlatformUserPlaylistTrack[];
+  getPlatformUserPlaylistTracks!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistTrack>;
+  setPlatformUserPlaylistTracks!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  addPlatformUserPlaylistTrack!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  addPlatformUserPlaylistTracks!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  createPlatformUserPlaylistTrack!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistTrack>;
+  removePlatformUserPlaylistTrack!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  removePlatformUserPlaylistTracks!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  hasPlatformUserPlaylistTrack!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  hasPlatformUserPlaylistTracks!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistTrack, PlatformUserPlaylistTrackId>;
+  countPlatformUserPlaylistTracks!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof State {
+    return State.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'state',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "state_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/TrackDeletionReason.ts

@@ -0,0 +1,58 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+
+export interface TrackDeletionReasonAttributes {
+  id: number;
+  description: string;
+}
+
+export type TrackDeletionReasonPk = "id";
+export type TrackDeletionReasonId = TrackDeletionReason[TrackDeletionReasonPk];
+export type TrackDeletionReasonCreationAttributes = TrackDeletionReasonAttributes;
+
+export class TrackDeletionReason extends Model<TrackDeletionReasonAttributes, TrackDeletionReasonCreationAttributes> implements TrackDeletionReasonAttributes {
+  id!: number;
+  description!: string;
+
+  // TrackDeletionReason hasMany JukeboxQueueEntry via trackDeletionReasonId
+  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 TrackDeletionReason {
+    return TrackDeletionReason.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'track_deletion_reason',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "track_deletion_reason_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UnmatchedAlbum.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface UnmatchedAlbumAttributes {
+  id: string;
+  platformAlbumId: string;
+  createDate: Date;
+}
+
+export type UnmatchedAlbumPk = "id";
+export type UnmatchedAlbumId = UnmatchedAlbum[UnmatchedAlbumPk];
+export type UnmatchedAlbumOptionalAttributes = "id" | "createDate";
+export type UnmatchedAlbumCreationAttributes = Optional<UnmatchedAlbumAttributes, UnmatchedAlbumOptionalAttributes>;
+
+export class UnmatchedAlbum extends Model<UnmatchedAlbumAttributes, UnmatchedAlbumCreationAttributes> implements UnmatchedAlbumAttributes {
+  id!: string;
+  platformAlbumId!: string;
+  createDate!: Date;
+
+  // UnmatchedAlbum belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+
+  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,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'platform_album_id'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'unmatched_album',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "unmatched_album_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UnmatchedArtist.ts

@@ -0,0 +1,81 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Platform, PlatformId } from './Platform';
+
+export interface UnmatchedArtistAttributes {
+  id: string;
+  platformId: number;
+  externalArtistId: number;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type UnmatchedArtistPk = "id";
+export type UnmatchedArtistId = UnmatchedArtist[UnmatchedArtistPk];
+export type UnmatchedArtistOptionalAttributes = "id" | "createDate" | "updateDate";
+export type UnmatchedArtistCreationAttributes = Optional<UnmatchedArtistAttributes, UnmatchedArtistOptionalAttributes>;
+
+export class UnmatchedArtist extends Model<UnmatchedArtistAttributes, UnmatchedArtistCreationAttributes> implements UnmatchedArtistAttributes {
+  id!: string;
+  platformId!: number;
+  externalArtistId!: number;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // UnmatchedArtist belongsTo Platform via platformId
+  platform!: Platform;
+  getPlatform!: Sequelize.BelongsToGetAssociationMixin<Platform>;
+  setPlatform!: Sequelize.BelongsToSetAssociationMixin<Platform, PlatformId>;
+  createPlatform!: Sequelize.BelongsToCreateAssociationMixin<Platform>;
+
+  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,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      field: 'platform_id'
+    },
+    externalArtistId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      field: 'external_artist_id'
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'unmatched_artist',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "unmatched_artist_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/UserContacts.ts

@@ -0,0 +1,149 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+
+export interface UserContactsAttributes {
+  appUserId: string;
+  contactId: string;
+  contactAppUserId?: string;
+  firstName?: string;
+  lastName?: string;
+  contactEmail1?: string;
+  contactEmail2?: string;
+  contactEmail3?: string;
+  contactPhone1?: string;
+  contactPhone1Type?: "mobile" | "work" | "home" | "main";
+  contactPhone2?: string;
+  contactPhone2Type?: "mobile" | "work" | "home" | "main";
+  contactPhone3?: string;
+  contactPhone3Type?: "mobile" | "work" | "home" | "main";
+  active?: boolean;
+}
+
+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 UserContactsCreationAttributes = Optional<UserContactsAttributes, UserContactsOptionalAttributes>;
+
+export class UserContacts extends Model<UserContactsAttributes, UserContactsCreationAttributes> implements UserContactsAttributes {
+  appUserId!: string;
+  contactId!: string;
+  contactAppUserId?: string;
+  firstName?: string;
+  lastName?: string;
+  contactEmail1?: string;
+  contactEmail2?: string;
+  contactEmail3?: string;
+  contactPhone1?: string;
+  contactPhone1Type?: "mobile" | "work" | "home" | "main";
+  contactPhone2?: string;
+  contactPhone2Type?: "mobile" | "work" | "home" | "main";
+  contactPhone3?: string;
+  contactPhone3Type?: "mobile" | "work" | "home" | "main";
+  active?: boolean;
+
+  // UserContacts belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof UserContacts {
+    return UserContacts.init({
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'app_user_id'
+    },
+    contactId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true,
+      field: 'contact_id'
+    },
+    contactAppUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'contact_app_user_id'
+    },
+    firstName: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'first_name'
+    },
+    lastName: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'last_name'
+    },
+    contactEmail1: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'contact_email_1'
+    },
+    contactEmail2: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'contact_email_2'
+    },
+    contactEmail3: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'contact_email_3'
+    },
+    contactPhone1: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'contact_phone_1'
+    },
+    contactPhone1Type: {
+      type: DataTypes.ENUM("mobile","work","home","main"),
+      allowNull: true,
+      field: 'contact_phone_1_type'
+    },
+    contactPhone2: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'contact_phone_2'
+    },
+    contactPhone2Type: {
+      type: DataTypes.ENUM("mobile","work","home","main"),
+      allowNull: true,
+      field: 'contact_phone_2_type'
+    },
+    contactPhone3: {
+      type: DataTypes.STRING(255),
+      allowNull: true,
+      field: 'contact_phone_3'
+    },
+    contactPhone3Type: {
+      type: DataTypes.ENUM("mobile","work","home","main"),
+      allowNull: true,
+      field: 'contact_phone_3_type'
+    },
+    active: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true
+    }
+  }, {
+    sequelize,
+    tableName: 'user_contacts',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "user_contacts_pkey",
+        unique: true,
+        fields: [
+          { name: "contact_id" },
+        ]
+      },
+    ]
+  });
+  }
+}