@earbug/db-models 0.0.1

package/models/AppUser.ts

@@ -0,0 +1,267 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUserDevice, AppUserDeviceId } from './AppUserDevice';
+import type { AppUserFollowRelation, AppUserFollowRelationId } from './AppUserFollowRelation';
+import type { AppUserPlatformRelation, AppUserPlatformRelationCreationAttributes, AppUserPlatformRelationId } from './AppUserPlatformRelation';
+import type { JukeboxInvite, JukeboxInviteId } from './JukeboxInvite';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+import type { PlatformUserAlbum, PlatformUserAlbumId } from './PlatformUserAlbum';
+import type { PlatformUserPlaylist, PlatformUserPlaylistId } from './PlatformUserPlaylist';
+import type { State, StateId } from './State';
+import type { UserContacts, UserContactsId } from './UserContacts';
+
+export interface AppUserAttributes {
+  id: string;
+  email: string;
+  firstName: string;
+  createDate: Date;
+  updateDate: Date;
+  stateId: number;
+  syncContacts?: boolean;
+  lastName?: string;
+  autoApproveFollowers: boolean;
+  lastHarvested?: Date;
+  lastHarvestedError?: string;
+}
+
+export type AppUserPk = "id";
+export type AppUserId = AppUser[AppUserPk];
+export type AppUserOptionalAttributes = "id" | "createDate" | "updateDate" | "stateId" | "syncContacts" | "lastName" | "autoApproveFollowers" | "lastHarvested" | "lastHarvestedError";
+export type AppUserCreationAttributes = Optional<AppUserAttributes, AppUserOptionalAttributes>;
+
+export class AppUser extends Model<AppUserAttributes, AppUserCreationAttributes> implements AppUserAttributes {
+  id!: string;
+  email!: string;
+  firstName!: string;
+  createDate!: Date;
+  updateDate!: Date;
+  stateId!: number;
+  syncContacts?: boolean;
+  lastName?: string;
+  autoApproveFollowers!: boolean;
+  lastHarvested?: Date;
+  lastHarvestedError?: string;
+
+  // AppUser hasMany AppUserDevice via appUserId
+  appUserDevices!: AppUserDevice[];
+  getAppUserDevices!: Sequelize.HasManyGetAssociationsMixin<AppUserDevice>;
+  setAppUserDevices!: Sequelize.HasManySetAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  addAppUserDevice!: Sequelize.HasManyAddAssociationMixin<AppUserDevice, AppUserDeviceId>;
+  addAppUserDevices!: Sequelize.HasManyAddAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  createAppUserDevice!: Sequelize.HasManyCreateAssociationMixin<AppUserDevice>;
+  removeAppUserDevice!: Sequelize.HasManyRemoveAssociationMixin<AppUserDevice, AppUserDeviceId>;
+  removeAppUserDevices!: Sequelize.HasManyRemoveAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  hasAppUserDevice!: Sequelize.HasManyHasAssociationMixin<AppUserDevice, AppUserDeviceId>;
+  hasAppUserDevices!: Sequelize.HasManyHasAssociationsMixin<AppUserDevice, AppUserDeviceId>;
+  countAppUserDevices!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany AppUserFollowRelation via appUserId
+  appUserFollowRelations!: AppUserFollowRelation[];
+  getAppUserFollowRelations!: Sequelize.HasManyGetAssociationsMixin<AppUserFollowRelation>;
+  setAppUserFollowRelations!: Sequelize.HasManySetAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addAppUserFollowRelation!: Sequelize.HasManyAddAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addAppUserFollowRelations!: Sequelize.HasManyAddAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  createAppUserFollowRelation!: Sequelize.HasManyCreateAssociationMixin<AppUserFollowRelation>;
+  removeAppUserFollowRelation!: Sequelize.HasManyRemoveAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  removeAppUserFollowRelations!: Sequelize.HasManyRemoveAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasAppUserFollowRelation!: Sequelize.HasManyHasAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasAppUserFollowRelations!: Sequelize.HasManyHasAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  countAppUserFollowRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany AppUserFollowRelation via followingAppUserId
+  followingAppUserAppUserFollowRelations!: AppUserFollowRelation[];
+  getFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyGetAssociationsMixin<AppUserFollowRelation>;
+  setFollowingAppUserAppUserFollowRelations!: Sequelize.HasManySetAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyAddAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  addFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyAddAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  createFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyCreateAssociationMixin<AppUserFollowRelation>;
+  removeFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyRemoveAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  removeFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyRemoveAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasFollowingAppUserAppUserFollowRelation!: Sequelize.HasManyHasAssociationMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  hasFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyHasAssociationsMixin<AppUserFollowRelation, AppUserFollowRelationId>;
+  countFollowingAppUserAppUserFollowRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasOne AppUserPlatformRelation via appUserId
+  appUserPlatformRelation!: AppUserPlatformRelation;
+  getAppUserPlatformRelation!: Sequelize.HasOneGetAssociationMixin<AppUserPlatformRelation>;
+  setAppUserPlatformRelation!: Sequelize.HasOneSetAssociationMixin<AppUserPlatformRelation, AppUserPlatformRelationId>;
+  createAppUserPlatformRelation!: Sequelize.HasOneCreateAssociationMixin<AppUserPlatformRelation>;
+  // AppUser hasMany JukeboxInvite via invitedUserId
+  jukeboxInvites!: JukeboxInvite[];
+  getJukeboxInvites!: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
+  setJukeboxInvites!: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  addJukeboxInvite!: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  addJukeboxInvites!: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  createJukeboxInvite!: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
+  removeJukeboxInvite!: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  removeJukeboxInvites!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  hasJukeboxInvite!: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  hasJukeboxInvites!: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  countJukeboxInvites!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany JukeboxInvite via inviterUserId
+  inviterUserJukeboxInvites!: JukeboxInvite[];
+  getInviterUserJukeboxInvites!: Sequelize.HasManyGetAssociationsMixin<JukeboxInvite>;
+  setInviterUserJukeboxInvites!: Sequelize.HasManySetAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  addInviterUserJukeboxInvite!: Sequelize.HasManyAddAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  addInviterUserJukeboxInvites!: Sequelize.HasManyAddAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  createInviterUserJukeboxInvite!: Sequelize.HasManyCreateAssociationMixin<JukeboxInvite>;
+  removeInviterUserJukeboxInvite!: Sequelize.HasManyRemoveAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  removeInviterUserJukeboxInvites!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  hasInviterUserJukeboxInvite!: Sequelize.HasManyHasAssociationMixin<JukeboxInvite, JukeboxInviteId>;
+  hasInviterUserJukeboxInvites!: Sequelize.HasManyHasAssociationsMixin<JukeboxInvite, JukeboxInviteId>;
+  countInviterUserJukeboxInvites!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany JukeboxQueueEntry via trackAddedUserId
+  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;
+  // AppUser hasMany JukeboxUser via appUserId
+  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;
+  // AppUser hasMany PlatformUserAlbum via appUserId
+  platformUserAlbums!: PlatformUserAlbum[];
+  getPlatformUserAlbums!: Sequelize.HasManyGetAssociationsMixin<PlatformUserAlbum>;
+  setPlatformUserAlbums!: Sequelize.HasManySetAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  addPlatformUserAlbum!: Sequelize.HasManyAddAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  addPlatformUserAlbums!: Sequelize.HasManyAddAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  createPlatformUserAlbum!: Sequelize.HasManyCreateAssociationMixin<PlatformUserAlbum>;
+  removePlatformUserAlbum!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  removePlatformUserAlbums!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  hasPlatformUserAlbum!: Sequelize.HasManyHasAssociationMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  hasPlatformUserAlbums!: Sequelize.HasManyHasAssociationsMixin<PlatformUserAlbum, PlatformUserAlbumId>;
+  countPlatformUserAlbums!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser hasMany PlatformUserPlaylist via appUserId
+  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;
+  // AppUser hasMany UserContacts via appUserId
+  userContacts!: UserContacts[];
+  getUserContacts!: Sequelize.HasManyGetAssociationsMixin<UserContacts>;
+  setUserContacts!: Sequelize.HasManySetAssociationsMixin<UserContacts, UserContactsId>;
+  addUserContact!: Sequelize.HasManyAddAssociationMixin<UserContacts, UserContactsId>;
+  addUserContacts!: Sequelize.HasManyAddAssociationsMixin<UserContacts, UserContactsId>;
+  createUserContact!: Sequelize.HasManyCreateAssociationMixin<UserContacts>;
+  removeUserContact!: Sequelize.HasManyRemoveAssociationMixin<UserContacts, UserContactsId>;
+  removeUserContacts!: Sequelize.HasManyRemoveAssociationsMixin<UserContacts, UserContactsId>;
+  hasUserContact!: Sequelize.HasManyHasAssociationMixin<UserContacts, UserContactsId>;
+  hasUserContacts!: Sequelize.HasManyHasAssociationsMixin<UserContacts, UserContactsId>;
+  countUserContacts!: Sequelize.HasManyCountAssociationsMixin;
+  // AppUser belongsTo State via stateId
+  state!: State;
+  getState!: Sequelize.BelongsToGetAssociationMixin<State>;
+  setState!: Sequelize.BelongsToSetAssociationMixin<State, StateId>;
+  createState!: Sequelize.BelongsToCreateAssociationMixin<State>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AppUser {
+    return AppUser.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    email: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "uk_app_user_email"
+    },
+    firstName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'first_name'
+    },
+    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'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'state',
+        key: 'id'
+      },
+      field: 'state_id'
+    },
+    syncContacts: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false,
+      field: 'sync_contacts'
+    },
+    lastName: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'last_name'
+    },
+    autoApproveFollowers: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: true,
+      field: 'auto_approve_followers'
+    },
+    lastHarvested: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'last_harvested'
+    },
+    lastHarvestedError: {
+      type: DataTypes.STRING(512),
+      allowNull: true,
+      field: 'last_harvested_error'
+    }
+  }, {
+    sequelize,
+    tableName: 'app_user',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_app_user_email",
+        unique: true,
+        fields: [
+          { name: "email" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AppUserDevice.ts

@@ -0,0 +1,88 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+
+export interface AppUserDeviceAttributes {
+  id: string;
+  appUserId: string;
+  devicePlatformId: number;
+  endpointArn: string;
+  createdAt: Date;
+}
+
+export type AppUserDevicePk = "id";
+export type AppUserDeviceId = AppUserDevice[AppUserDevicePk];
+export type AppUserDeviceOptionalAttributes = "id" | "createdAt";
+export type AppUserDeviceCreationAttributes = Optional<AppUserDeviceAttributes, AppUserDeviceOptionalAttributes>;
+
+export class AppUserDevice extends Model<AppUserDeviceAttributes, AppUserDeviceCreationAttributes> implements AppUserDeviceAttributes {
+  id!: string;
+  appUserId!: string;
+  devicePlatformId!: number;
+  endpointArn!: string;
+  createdAt!: Date;
+
+  // AppUserDevice 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 AppUserDevice {
+    return AppUserDevice.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      field: 'app_user_id'
+    },
+    devicePlatformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      field: 'device_platform_id'
+    },
+    endpointArn: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "unique_app_user_device_endpoint_arn",
+      field: 'endpoint_arn'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'app_user_device',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_device_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "unique_app_user_device_endpoint_arn",
+        unique: true,
+        fields: [
+          { name: "endpoint_arn" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AppUserFollowRelation.ts

@@ -0,0 +1,122 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+
+export interface AppUserFollowRelationAttributes {
+  id: string;
+  appUserId: string;
+  followingAppUserId: string;
+  stateId: number;
+  isBlocked: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type AppUserFollowRelationPk = "id";
+export type AppUserFollowRelationId = AppUserFollowRelation[AppUserFollowRelationPk];
+export type AppUserFollowRelationOptionalAttributes = "id" | "stateId" | "createdAt" | "updatedAt";
+export type AppUserFollowRelationCreationAttributes = Optional<AppUserFollowRelationAttributes, AppUserFollowRelationOptionalAttributes>;
+
+export class AppUserFollowRelation extends Model<AppUserFollowRelationAttributes, AppUserFollowRelationCreationAttributes> implements AppUserFollowRelationAttributes {
+  id!: string;
+  appUserId!: string;
+  followingAppUserId!: string;
+  stateId!: number;
+  isBlocked!: boolean;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // AppUserFollowRelation belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // AppUserFollowRelation belongsTo AppUser via followingAppUserId
+  followingAppUser!: AppUser;
+  getFollowingAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setFollowingAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createFollowingAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AppUserFollowRelation {
+    return AppUserFollowRelation.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "unique_app_user_followers",
+      field: 'app_user_id'
+    },
+    followingAppUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "unique_app_user_followers",
+      field: 'following_app_user_id'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'state_id'
+    },
+    isBlocked: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+      defaultValue: false,
+      field: 'is_blocked'
+    },
+    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: 'app_user_follow_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_follow_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "app_user_id",
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "unique_app_user_followers",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+          { name: "following_app_user_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AppUserPlatformRelation.ts

@@ -0,0 +1,150 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Platform, PlatformId } from './Platform';
+
+export interface AppUserPlatformRelationAttributes {
+  id: string;
+  appUserId: string;
+  platformId: number;
+  externalUserId: string;
+  createDate: Date;
+  updateDate: Date;
+  accessToken: string;
+  refreshToken?: string;
+  expirationDate: Date;
+  countryCode: string;
+  stateId: number;
+}
+
+export type AppUserPlatformRelationPk = "id";
+export type AppUserPlatformRelationId = AppUserPlatformRelation[AppUserPlatformRelationPk];
+export type AppUserPlatformRelationOptionalAttributes = "id" | "createDate" | "updateDate" | "refreshToken" | "stateId";
+export type AppUserPlatformRelationCreationAttributes = Optional<AppUserPlatformRelationAttributes, AppUserPlatformRelationOptionalAttributes>;
+
+export class AppUserPlatformRelation extends Model<AppUserPlatformRelationAttributes, AppUserPlatformRelationCreationAttributes> implements AppUserPlatformRelationAttributes {
+  id!: string;
+  appUserId!: string;
+  platformId!: number;
+  externalUserId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+  accessToken!: string;
+  refreshToken?: string;
+  expirationDate!: Date;
+  countryCode!: string;
+  stateId!: number;
+
+  // AppUserPlatformRelation belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // AppUserPlatformRelation 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 AppUserPlatformRelation {
+    return AppUserPlatformRelation.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "uk_platform_relation_app_user_id",
+      field: 'app_user_id'
+    },
+    platformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'platform',
+        key: 'id'
+      },
+      field: 'platform_id'
+    },
+    externalUserId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'external_user_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'
+    },
+    accessToken: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      field: 'access_token'
+    },
+    refreshToken: {
+      type: DataTypes.STRING,
+      allowNull: true,
+      field: 'refresh_token'
+    },
+    expirationDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      field: 'expiration_date'
+    },
+    countryCode: {
+      type: DataTypes.STRING(2),
+      allowNull: false,
+      field: 'country_code'
+    },
+    stateId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      field: 'state_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'app_user_platform_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "app_user_platform_relation_app_user_id_platform_id_idx",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+          { name: "platform_id" },
+        ]
+      },
+      {
+        name: "app_user_platform_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "uk_platform_relation_app_user_id",
+        unique: true,
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+    ]
+  });
+  }
+}