@earbug/db-models 0.0.14 → 0.0.16

package/models/GuestUser.ts

@@ -0,0 +1,108 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 class GuestUser extends Model<GuestUserAttributes, GuestUserCreationAttributes> implements GuestUserAttributes {
+  firstName!: string;
+  lastName?: string;
+  jukeboxSessionId!: string;
+  ipAddress?: string;
+  id!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // GuestUser hasMany JukeboxQueueEntry via trackAddedGuestUserId
+  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;
+  // GuestUser 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 GuestUser {
+    return GuestUser.init({
+    firstName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'first_name'
+    },
+    lastName: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'last_name'
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      field: 'jukebox_session_id'
+    },
+    ipAddress: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'ip_address'
+    },
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    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: 'guest_user',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "guest_user_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxQueueEntry.ts

@@ -2,16 +2,16 @@ 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 {
   jukeboxSessionId: string;
-  trackId: string;
   playbackPriority?: number;
-  trackAddedUserId: string;
   playbackStarted?: Date;
   id: string;
   createdAt: Date;
@@ -19,20 +19,22 @@ 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 class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, JukeboxQueueEntryCreationAttributes> implements JukeboxQueueEntryAttributes {
   jukeboxSessionId!: string;
-  trackId!: string;
   playbackPriority?: number;
-  trackAddedUserId!: string;
   playbackStarted?: Date;
   id!: string;
   createdAt!: Date;
@@ -40,8 +42,12 @@ export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, Jukebo
   setOrder!: number;
   trackDeletionReasonId!: number;
   playbackStatusTypeId!: number;
+  trackId?: string;
+  trackAddedUserId?: string;
   trackThumbsUp?: string[];
   trackThumbsDown?: string[];
+  platformTrackId?: string;
+  trackAddedGuestUserId?: string;
 
   // JukeboxQueueEntry belongsTo AppUser via trackAddedUserId
   trackAddedUser!: AppUser;
@@ -53,6 +59,11 @@ export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, Jukebo
   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>;
@@ -70,6 +81,11 @@ export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, Jukebo
   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>;
@@ -92,29 +108,11 @@ export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, Jukebo
       },
       field: 'jukebox_session_id'
     },
-    trackId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'canon_track',
-        key: 'id'
-      },
-      field: 'track_id'
-    },
     playbackPriority: {
       type: DataTypes.DECIMAL,
       allowNull: true,
       field: 'playback_priority'
     },
-    trackAddedUserId: {
-      type: DataTypes.UUID,
-      allowNull: false,
-      references: {
-        model: 'app_user',
-        key: 'id'
-      },
-      field: 'track_added_user_id'
-    },
     playbackStarted: {
       type: DataTypes.DATE,
       allowNull: true,
@@ -164,6 +162,24 @@ export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, Jukebo
       },
       field: 'playback_status_type_id'
     },
+    trackId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'canon_track',
+        key: 'id'
+      },
+      field: 'track_id'
+    },
+    trackAddedUserId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'track_added_user_id'
+    },
     trackThumbsUp: {
       type: DataTypes.ARRAY(DataTypes.UUID),
       allowNull: true,
@@ -175,6 +191,24 @@ export class JukeboxQueueEntry extends Model<JukeboxQueueEntryAttributes, Jukebo
       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,

package/models/JukeboxSession.ts

@@ -1,5 +1,6 @@
 import * as Sequelize from 'sequelize';
 import { DataTypes, 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';
@@ -55,6 +56,18 @@ export class JukeboxSession extends Model<JukeboxSessionAttributes, JukeboxSessi
   getJukeboxQueueMode!: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueMode>;
   setJukeboxQueueMode!: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueMode, JukeboxQueueModeId>;
   createJukeboxQueueMode!: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueMode>;
+  // JukeboxSession hasMany GuestUser via jukeboxSessionId
+  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;
   // JukeboxSession hasMany JukeboxCanonGenreRelation via jukeboxSessionId
   jukeboxCanonGenreRelations!: JukeboxCanonGenreRelation[];
   getJukeboxCanonGenreRelations!: Sequelize.HasManyGetAssociationsMixin<JukeboxCanonGenreRelation>;

package/models/MerchItem.ts

@@ -0,0 +1,146 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, 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 {
+  id: string;
+  canonArtistId: string;
+  merchTypeId: string;
+  merchPlatformId: string;
+  merchItemPlatformId: string;
+  title: string;
+  description: string;
+  photo?: string;
+  popularity?: number;
+  inactive?: boolean;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type MerchItemPk = "id";
+export type MerchItemId = MerchItem[MerchItemPk];
+export type MerchItemOptionalAttributes = "id" | "photo" | "popularity" | "inactive" | "createDate" | "updateDate";
+export type MerchItemCreationAttributes = Optional<MerchItemAttributes, MerchItemOptionalAttributes>;
+
+export class MerchItem extends Model<MerchItemAttributes, MerchItemCreationAttributes> implements MerchItemAttributes {
+  id!: string;
+  canonArtistId!: string;
+  merchTypeId!: string;
+  merchPlatformId!: string;
+  merchItemPlatformId!: string;
+  title!: string;
+  description!: string;
+  photo?: string;
+  popularity?: number;
+  inactive?: boolean;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // MerchItem belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+  // MerchItem belongsTo MerchPlatform via merchPlatformId
+  merchPlatform!: MerchPlatform;
+  getMerchPlatform!: Sequelize.BelongsToGetAssociationMixin<MerchPlatform>;
+  setMerchPlatform!: Sequelize.BelongsToSetAssociationMixin<MerchPlatform, MerchPlatformId>;
+  createMerchPlatform!: Sequelize.BelongsToCreateAssociationMixin<MerchPlatform>;
+  // MerchItem belongsTo MerchType via merchTypeId
+  merchType!: MerchType;
+  getMerchType!: Sequelize.BelongsToGetAssociationMixin<MerchType>;
+  setMerchType!: Sequelize.BelongsToSetAssociationMixin<MerchType, MerchTypeId>;
+  createMerchType!: Sequelize.BelongsToCreateAssociationMixin<MerchType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof MerchItem {
+    return MerchItem.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    merchTypeId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'merch_type',
+        key: 'id'
+      },
+      field: 'merch_type_id'
+    },
+    merchPlatformId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'merch_platform',
+        key: 'id'
+      },
+      field: 'merch_platform_id'
+    },
+    merchItemPlatformId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'merch_item_platform_id'
+    },
+    title: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    photo: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    popularity: {
+      type: DataTypes.SMALLINT,
+      allowNull: true
+    },
+    inactive: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false
+    },
+    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: 'merch_item',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "merch_item_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/MerchOrchestration.ts

@@ -0,0 +1,122 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { MerchPlatform, MerchPlatformId } from './MerchPlatform';
+import type { MerchType, MerchTypeId } from './MerchType';
+
+export interface MerchOrchestrationAttributes {
+  id: string;
+  canonArtistId: string;
+  merchTypeId: string;
+  merchPlatformId: string;
+  errorMessage?: string;
+  lastHarvestDate?: Date;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type MerchOrchestrationPk = "id";
+export type MerchOrchestrationId = MerchOrchestration[MerchOrchestrationPk];
+export type MerchOrchestrationOptionalAttributes = "id" | "errorMessage" | "lastHarvestDate" | "createDate" | "updateDate";
+export type MerchOrchestrationCreationAttributes = Optional<MerchOrchestrationAttributes, MerchOrchestrationOptionalAttributes>;
+
+export class MerchOrchestration extends Model<MerchOrchestrationAttributes, MerchOrchestrationCreationAttributes> implements MerchOrchestrationAttributes {
+  id!: string;
+  canonArtistId!: string;
+  merchTypeId!: string;
+  merchPlatformId!: string;
+  errorMessage?: string;
+  lastHarvestDate?: Date;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // MerchOrchestration belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+  // MerchOrchestration belongsTo MerchPlatform via merchPlatformId
+  merchPlatform!: MerchPlatform;
+  getMerchPlatform!: Sequelize.BelongsToGetAssociationMixin<MerchPlatform>;
+  setMerchPlatform!: Sequelize.BelongsToSetAssociationMixin<MerchPlatform, MerchPlatformId>;
+  createMerchPlatform!: Sequelize.BelongsToCreateAssociationMixin<MerchPlatform>;
+  // MerchOrchestration belongsTo MerchType via merchTypeId
+  merchType!: MerchType;
+  getMerchType!: Sequelize.BelongsToGetAssociationMixin<MerchType>;
+  setMerchType!: Sequelize.BelongsToSetAssociationMixin<MerchType, MerchTypeId>;
+  createMerchType!: Sequelize.BelongsToCreateAssociationMixin<MerchType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof MerchOrchestration {
+    return MerchOrchestration.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    merchTypeId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'merch_type',
+        key: 'id'
+      },
+      field: 'merch_type_id'
+    },
+    merchPlatformId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'merch_platform',
+        key: 'id'
+      },
+      field: 'merch_platform_id'
+    },
+    errorMessage: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'error_message'
+    },
+    lastHarvestDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_harvest_date'
+    },
+    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: 'merch_orchestration',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "merch_orchestration_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/MerchPlatform.ts

@@ -0,0 +1,95 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { MerchItem, MerchItemId } from './MerchItem';
+import type { MerchOrchestration, MerchOrchestrationId } from './MerchOrchestration';
+
+export interface MerchPlatformAttributes {
+  id: string;
+  name: string;
+  host: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type MerchPlatformPk = "id";
+export type MerchPlatformId = MerchPlatform[MerchPlatformPk];
+export type MerchPlatformOptionalAttributes = "id" | "createDate" | "updateDate";
+export type MerchPlatformCreationAttributes = Optional<MerchPlatformAttributes, MerchPlatformOptionalAttributes>;
+
+export class MerchPlatform extends Model<MerchPlatformAttributes, MerchPlatformCreationAttributes> implements MerchPlatformAttributes {
+  id!: string;
+  name!: string;
+  host!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // MerchPlatform hasMany MerchItem via merchPlatformId
+  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;
+  // MerchPlatform hasMany MerchOrchestration via merchPlatformId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof MerchPlatform {
+    return MerchPlatform.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    host: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    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: 'merch_platform',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "merch_platform_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}