@earbug/db-models 0.0.62 → 0.0.63

package/.dockerignore

@@ -0,0 +1,10 @@
+*
+!.dockerignore
+!Dockerfile.generate
+!package.json
+!package-lock.json
+!model_options.json
+!models/
+!models/**
+!scripts/
+!scripts/generate-and-upload.mjs

package/.github/workflows/publish.yaml

@@ -0,0 +1,303 @@
+name: Regenerate Models and Publish
+
+on:
+  repository_dispatch:
+    types: [migration_completed]
+
+concurrency:
+  group: db-models-publish
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    name: Regenerate, Build, and Publish
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    environment: dev
+    env:
+      AWS_REGION: us-east-1
+      SSM_PREFIX: /earbug-dev/db-models
+      AWS_ACCOUNT_ID: "630596767721"
+      ECR_REGISTRY_ACCOUNT_ID: "146319281891"
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6
+        with:
+          persist-credentials: false
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@7474bc4690e29a8392af63c5b98e7449536d5c3a # v4
+        with:
+          role-to-assume: arn:aws:iam::630596767721:role/earbug-db-models-ci-dev
+          aws-region: ${{ env.AWS_REGION }}
+
+      - name: Read ECS job configuration
+        run: |
+          set -euo pipefail
+
+          get_parameter() {
+            aws ssm get-parameter \
+              --name "$SSM_PREFIX/$1" \
+              --query Parameter.Value \
+              --output text
+          }
+
+          ECS_CLUSTER="$(get_parameter cluster-arn)"
+          PRIVATE_SUBNETS="$(get_parameter subnets)"
+          SECURITY_GROUP_ID="$(get_parameter security-group-id)"
+          TASK_ROLE_ARN="$(get_parameter task-role-arn)"
+          EXECUTION_ROLE_ARN="$(get_parameter execution-role-arn)"
+          LOG_GROUP_NAME="$(get_parameter log-group-name)"
+          ECR_REGISTRY="$(get_parameter ecr-registry)"
+          ECR_REPO="$(get_parameter ecr-repo)"
+          TASK_FAMILY="$(get_parameter task-family)"
+          RDS_SECRET_ARN="$(get_parameter rds-secret-arn)"
+          PG_SSL="$(get_parameter pg-ssl)"
+          ARTIFACT_BUCKET="$(get_parameter artifact-bucket)"
+          ARTIFACT_PREFIX="$(get_parameter artifact-prefix)"
+
+          for name in ECS_CLUSTER PRIVATE_SUBNETS SECURITY_GROUP_ID TASK_ROLE_ARN EXECUTION_ROLE_ARN \
+            LOG_GROUP_NAME ECR_REGISTRY ECR_REPO TASK_FAMILY RDS_SECRET_ARN PG_SSL \
+            ARTIFACT_BUCKET ARTIFACT_PREFIX; do
+            value="${!name}"
+            if [ -z "$value" ] || [ "$value" = "None" ] || [[ "$value" == *$'\n'* ]]; then
+              echo "::error::Invalid $name value from SSM"
+              exit 1
+            fi
+          done
+
+          if [ "$PG_SSL" != "true" ]; then
+            echo "::error::PG_SSL must be true"
+            exit 1
+          fi
+
+          EXPECTED_ECR_REGISTRY="${ECR_REGISTRY_ACCOUNT_ID}.dkr.ecr.${AWS_REGION}.amazonaws.com"
+          EXPECTED_CLUSTER="arn:aws:ecs:${AWS_REGION}:${AWS_ACCOUNT_ID}:cluster/earbug-dev-cluster"
+          EXPECTED_TASK_ROLE="arn:aws:iam::${AWS_ACCOUNT_ID}:role/earbug-dev-db-models-ecs-task-role"
+          EXPECTED_EXECUTION_ROLE="arn:aws:iam::${AWS_ACCOUNT_ID}:role/earbug-dev-db-models-ecs-execution-role"
+
+          [ "$ECS_CLUSTER" = "$EXPECTED_CLUSTER" ] || { echo "::error::Unexpected ECS cluster"; exit 1; }
+          [ "$TASK_ROLE_ARN" = "$EXPECTED_TASK_ROLE" ] || { echo "::error::Unexpected task role"; exit 1; }
+          [ "$EXECUTION_ROLE_ARN" = "$EXPECTED_EXECUTION_ROLE" ] || { echo "::error::Unexpected execution role"; exit 1; }
+          [ "$ECR_REGISTRY" = "$EXPECTED_ECR_REGISTRY" ] || { echo "::error::Unexpected ECR registry"; exit 1; }
+          [ "$ECR_REPO" = "earbug/db-models-generate" ] || { echo "::error::Unexpected ECR repository"; exit 1; }
+          [ "$TASK_FAMILY" = "earbug-dev-db-models" ] || { echo "::error::Unexpected task family"; exit 1; }
+          [ "$LOG_GROUP_NAME" = "/ecs/earbug-dev-db-models" ] || { echo "::error::Unexpected log group"; exit 1; }
+          [[ "$PRIVATE_SUBNETS" =~ ^subnet-[a-z0-9]+(,subnet-[a-z0-9]+)*$ ]] || { echo "::error::Invalid subnet list"; exit 1; }
+          [[ "$SECURITY_GROUP_ID" =~ ^sg-[a-z0-9]+$ ]] || { echo "::error::Invalid security group"; exit 1; }
+          [[ "$RDS_SECRET_ARN" =~ ^arn:aws:secretsmanager:${AWS_REGION}:${AWS_ACCOUNT_ID}:secret:rds/earbug-dev/credentials-[A-Za-z0-9_-]+$ ]] || { echo "::error::Unexpected RDS secret ARN"; exit 1; }
+          [ "$ARTIFACT_BUCKET" = "earbug-dev-db-models-artifacts" ] || { echo "::error::Unexpected artifact bucket"; exit 1; }
+          [ "$ARTIFACT_PREFIX" = "models/" ] || { echo "::error::Unexpected artifact prefix"; exit 1; }
+
+          {
+            printf 'ECS_CLUSTER=%s\n' "$ECS_CLUSTER"
+            printf 'PRIVATE_SUBNETS=%s\n' "$PRIVATE_SUBNETS"
+            printf 'SECURITY_GROUP_ID=%s\n' "$SECURITY_GROUP_ID"
+            printf 'TASK_ROLE_ARN=%s\n' "$TASK_ROLE_ARN"
+            printf 'EXECUTION_ROLE_ARN=%s\n' "$EXECUTION_ROLE_ARN"
+            printf 'LOG_GROUP_NAME=%s\n' "$LOG_GROUP_NAME"
+            printf 'ECR_REGISTRY=%s\n' "$ECR_REGISTRY"
+            printf 'ECR_REPO=%s\n' "$ECR_REPO"
+            printf 'TASK_FAMILY=%s\n' "$TASK_FAMILY"
+            printf 'RDS_SECRET_ARN=%s\n' "$RDS_SECRET_ARN"
+            printf 'PG_SSL=%s\n' "$PG_SSL"
+            printf 'ARTIFACT_BUCKET=%s\n' "$ARTIFACT_BUCKET"
+            printf 'ARTIFACT_PREFIX=%s\n' "$ARTIFACT_PREFIX"
+          } >> "$GITHUB_ENV"
+
+      - name: Build and push generator image
+        run: |
+          set -euo pipefail
+          IMAGE_TAG="${GITHUB_SHA}-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}"
+          IMAGE_URI="${ECR_REGISTRY}/${ECR_REPO}:${IMAGE_TAG}"
+          aws ecr get-login-password --region "$AWS_REGION" \
+            | docker login --username AWS --password-stdin "$ECR_REGISTRY"
+          docker build -f Dockerfile.generate -t "$IMAGE_URI" .
+          docker push "$IMAGE_URI"
+          echo "IMAGE_URI=$IMAGE_URI" >> "$GITHUB_ENV"
+
+      - name: Register model-generation task
+        run: |
+          set -euo pipefail
+          ARTIFACT_KEY="${ARTIFACT_PREFIX}${GITHUB_RUN_ID}-${GITHUB_SHA}/models.tgz"
+          jq -n \
+            --arg family "$TASK_FAMILY" \
+            --arg taskRoleArn "$TASK_ROLE_ARN" \
+            --arg executionRoleArn "$EXECUTION_ROLE_ARN" \
+            --arg image "$IMAGE_URI" \
+            --arg region "$AWS_REGION" \
+            --arg logGroup "$LOG_GROUP_NAME" \
+            --arg secretArn "$RDS_SECRET_ARN" \
+            --arg pgSsl "$PG_SSL" \
+            --arg artifactBucket "$ARTIFACT_BUCKET" \
+            --arg artifactKey "$ARTIFACT_KEY" \
+            '{
+              family: $family,
+              networkMode: "awsvpc",
+              requiresCompatibilities: ["FARGATE"],
+              cpu: "512",
+              memory: "1024",
+              taskRoleArn: $taskRoleArn,
+              executionRoleArn: $executionRoleArn,
+              containerDefinitions: [{
+                name: "db-models",
+                image: $image,
+                essential: true,
+                environment: [
+                  {name: "AWS_REGION", value: $region},
+                  {name: "PG_SSL", value: $pgSsl},
+                  {name: "ARTIFACT_BUCKET", value: $artifactBucket},
+                  {name: "ARTIFACT_KEY", value: $artifactKey}
+                ],
+                secrets: [
+                  {name: "PGHOST", valueFrom: ($secretArn + ":host::")},
+                  {name: "PGPORT", valueFrom: ($secretArn + ":port::")},
+                  {name: "PGUSER", valueFrom: ($secretArn + ":username::")},
+                  {name: "PGPASSWORD", valueFrom: ($secretArn + ":password::")},
+                  {name: "PGDATABASE", valueFrom: ($secretArn + ":dbname::")}
+                ],
+                logConfiguration: {
+                  logDriver: "awslogs",
+                  options: {
+                    "awslogs-group": $logGroup,
+                    "awslogs-region": $region,
+                    "awslogs-stream-prefix": "db-models"
+                  }
+                }
+              }]
+            }' > /tmp/task-definition.json
+
+          TASK_DEFINITION_ARN=$(aws ecs register-task-definition \
+            --cli-input-json file:///tmp/task-definition.json \
+            --query taskDefinition.taskDefinitionArn \
+            --output text)
+          echo "TASK_DEFINITION_ARN=$TASK_DEFINITION_ARN" >> "$GITHUB_ENV"
+          echo "ARTIFACT_KEY=$ARTIFACT_KEY" >> "$GITHUB_ENV"
+
+      - name: Run model-generation task
+        run: |
+          set -euo pipefail
+          NETWORK_CONFIGURATION=$(jq -cn \
+            --arg subnets "$PRIVATE_SUBNETS" \
+            --arg securityGroup "$SECURITY_GROUP_ID" \
+            '{awsvpcConfiguration: {
+              subnets: ($subnets | split(",")),
+              securityGroups: [$securityGroup],
+              assignPublicIp: "DISABLED"
+            }}')
+
+          RUN_RESULT=$(aws ecs run-task \
+            --cluster "$ECS_CLUSTER" \
+            --launch-type FARGATE \
+            --task-definition "$TASK_DEFINITION_ARN" \
+            --network-configuration "$NETWORK_CONFIGURATION" \
+            --started-by "github-${GITHUB_RUN_ID}")
+          TASK_ARN=$(jq -r '.tasks[0].taskArn // empty' <<< "$RUN_RESULT")
+
+          if [ -z "$TASK_ARN" ]; then
+            jq '.failures' <<< "$RUN_RESULT"
+            exit 1
+          fi
+
+          echo "TASK_ARN=$TASK_ARN" >> "$GITHUB_ENV"
+          aws ecs wait tasks-stopped --cluster "$ECS_CLUSTER" --tasks "$TASK_ARN"
+
+      - name: Check model-generation result
+        run: |
+          set -euo pipefail
+          TASK_RESULT=$(aws ecs describe-tasks --cluster "$ECS_CLUSTER" --tasks "$TASK_ARN")
+          EXIT_CODE=$(jq -r '.tasks[0].containers[] | select(.name == "db-models") | .exitCode // -1' <<< "$TASK_RESULT")
+
+          if [ "$EXIT_CODE" -ne 0 ]; then
+            TASK_ID="${TASK_ARN##*/}"
+            LOG_STREAM="db-models/db-models/${TASK_ID}"
+            jq -r '.tasks[0] | "Stopped reason: " + (.stoppedReason // "unknown")' <<< "$TASK_RESULT"
+            echo "Task logs: ${LOG_GROUP_NAME}/${LOG_STREAM}"
+            exit 1
+          fi
+
+      - name: Download generated models
+        run: |
+          set -euo pipefail
+          aws s3 cp \
+            "s3://${ARTIFACT_BUCKET}/${ARTIFACT_KEY}" \
+            /tmp/models.tgz \
+            --checksum-mode ENABLED \
+            --only-show-errors
+          rm -rf /tmp/generated-models
+          mkdir /tmp/generated-models
+          tar -tzf /tmp/models.tgz > /tmp/models.members
+          while IFS= read -r member; do
+            case "$member" in
+              models|models/|models/*) ;;
+              *) echo "::error::Artifact contains files outside models/"; exit 1 ;;
+            esac
+            case "/$member/" in
+              */../*) echo "::error::Artifact contains a parent-directory path"; exit 1 ;;
+            esac
+            case "$member" in
+              models/index.ts|models/initDb.ts|models/rdsCaBundle.ts)
+                echo "::error::Artifact contains a hand-maintained file"
+                exit 1
+                ;;
+            esac
+          done < /tmp/models.members
+          tar -tvzf /tmp/models.tgz > /tmp/models.verbose
+          if awk 'substr($1, 1, 1) !~ /^[-d]$/ { found=1 } END { exit !found }' /tmp/models.verbose; then
+            echo "::error::Artifact contains a link or special file"
+            exit 1
+          fi
+          tar --no-same-owner --no-same-permissions -xzf /tmp/models.tgz -C /tmp/generated-models
+          for maintained in index.ts initDb.ts rdsCaBundle.ts; do
+            if [ -e "/tmp/generated-models/models/$maintained" ] || [ -L "/tmp/generated-models/models/$maintained" ]; then
+              echo "::error::Artifact contains hand-maintained file $maintained"
+              exit 1
+            fi
+          done
+          find models -mindepth 1 -maxdepth 1 \
+            ! -name index.ts ! -name initDb.ts ! -name rdsCaBundle.ts \
+            -exec rm -rf {} +
+          cp -a /tmp/generated-models/models/. models/
+          git diff --exit-code -- models/index.ts models/initDb.ts models/rdsCaBundle.ts
+
+      - name: Verify models were generated
+        run: |
+          set -euo pipefail
+          COUNT=$(grep -cE '^import \{ .* as _.* \} from "\./' models/init-models.ts || true)
+          echo "init-models.ts imports $COUNT models"
+          if [ "$COUNT" -lt 25 ]; then
+            echo "::error::Only $COUNT models generated (expected >= 25). Refusing to build or publish."
+            exit 1
+          fi
+
+      - uses: actions/setup-node@249970729cb0ef3589644e2896645e5dc5ba9c38 # v6
+        with:
+          node-version: 24
+          registry-url: https://registry.npmjs.org
+
+      - run: npm ci --ignore-scripts
+
+      - name: Build
+        run: npm run build
+
+      - name: Bump patch version
+        id: version
+        run: echo "version=$(npm version patch --no-git-tag-version)" >> "$GITHUB_OUTPUT"
+
+      - name: Publish to npm
+        run: npm publish --access public
+
+      - name: Commit and push changes
+        env:
+          GH_TOKEN: ${{ secrets.MODELS_DISPATCH_TOKEN }}
+          VERSION: ${{ steps.version.outputs.version }}
+        run: |
+          set -euo pipefail
+          gh auth setup-git
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add models/ package.json
+          git commit -m "$VERSION - regenerate dev models and publish"
+          git push

package/.nvmrc

@@ -0,0 +1 @@
+24

package/Dockerfile.generate

@@ -0,0 +1,19 @@
+FROM amazon/aws-cli@sha256:92de75724b6a746951f0e8b915d86bbccd7cb55aff96cd0cb4f7017272160780 AS awscli
+FROM node:24-bookworm-slim@sha256:eae779f20e0cdf264247f6f3b4e62510d91f168a615117ed38430ba295f55590
+
+COPY --from=awscli /usr/local/aws-cli /usr/local/aws-cli
+RUN ln -s /usr/local/aws-cli/v2/current/bin/aws /usr/local/bin/aws
+
+WORKDIR /app
+
+COPY package.json package-lock.json ./
+RUN npm ci --ignore-scripts \
+    && sed -i 's/\^(char/\^(citext|char/' node_modules/sequelize-auto/lib/auto-generator.js
+
+COPY --chown=node:node model_options.json ./
+COPY --chown=node:node models ./models
+COPY --chown=node:node scripts/generate-and-upload.mjs ./scripts/generate-and-upload.mjs
+
+USER node
+
+CMD ["node", "scripts/generate-and-upload.mjs"]

package/model_options.json

@@ -0,0 +1,3 @@
+{
+  "timestamps": false
+}

package/models/AccessControlPreference.ts

@@ -0,0 +1,53 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface AccessControlPreferenceAttributes {
+  id: number;
+  name: string;
+}
+
+export type AccessControlPreferencePk = "id";
+export type AccessControlPreferenceId = AccessControlPreference[AccessControlPreferencePk];
+export type AccessControlPreferenceCreationAttributes = AccessControlPreferenceAttributes;
+
+export class AccessControlPreference extends Model<AccessControlPreferenceAttributes, AccessControlPreferenceCreationAttributes> implements AccessControlPreferenceAttributes {
+  id!: number;
+  name!: string;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AccessControlPreference {
+    return AccessControlPreference.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      unique: "access_control_preference_name_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'access_control_preference',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "access_control_preference_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "access_control_preference_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AffinityRelationshipType.ts

@@ -0,0 +1,96 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { UserAffinity, UserAffinityId } from './UserAffinity';
+
+export interface AffinityRelationshipTypeAttributes {
+  id: string;
+  name: string;
+  category: string;
+  tier: string;
+  createDate?: Date;
+  updateDate?: Date;
+}
+
+export type AffinityRelationshipTypePk = "id";
+export type AffinityRelationshipTypeId = AffinityRelationshipType[AffinityRelationshipTypePk];
+export type AffinityRelationshipTypeOptionalAttributes = "id" | "createDate" | "updateDate";
+export type AffinityRelationshipTypeCreationAttributes = Optional<AffinityRelationshipTypeAttributes, AffinityRelationshipTypeOptionalAttributes>;
+
+export class AffinityRelationshipType extends Model<AffinityRelationshipTypeAttributes, AffinityRelationshipTypeCreationAttributes> implements AffinityRelationshipTypeAttributes {
+  id!: string;
+  name!: string;
+  category!: string;
+  tier!: string;
+  createDate?: Date;
+  updateDate?: Date;
+
+  // AffinityRelationshipType hasMany UserAffinity via affinityRelationshipTypeId
+  userAffinities!: UserAffinity[];
+  getUserAffinities!: Sequelize.HasManyGetAssociationsMixin<UserAffinity>;
+  setUserAffinities!: Sequelize.HasManySetAssociationsMixin<UserAffinity, UserAffinityId>;
+  addUserAffinity!: Sequelize.HasManyAddAssociationMixin<UserAffinity, UserAffinityId>;
+  addUserAffinities!: Sequelize.HasManyAddAssociationsMixin<UserAffinity, UserAffinityId>;
+  createUserAffinity!: Sequelize.HasManyCreateAssociationMixin<UserAffinity>;
+  removeUserAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserAffinity, UserAffinityId>;
+  removeUserAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserAffinity, UserAffinityId>;
+  hasUserAffinity!: Sequelize.HasManyHasAssociationMixin<UserAffinity, UserAffinityId>;
+  hasUserAffinities!: Sequelize.HasManyHasAssociationsMixin<UserAffinity, UserAffinityId>;
+  countUserAffinities!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AffinityRelationshipType {
+    return AffinityRelationshipType.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      unique: "affinity_relationship_type_name_unique"
+    },
+    category: {
+      type: DataTypes.STRING(20),
+      allowNull: false
+    },
+    tier: {
+      type: DataTypes.STRING(20),
+      allowNull: false
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'affinity_relationship_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "affinity_relationship_type_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "affinity_relationship_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/AffinityTier.ts

@@ -0,0 +1,131 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId } from './JukeboxSessionArtistAffinity';
+import type { JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId } from './JukeboxSessionGenreAffinity';
+import type { PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId } from './PlatformUserPlaylistArtistAffinity';
+import type { PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId } from './PlatformUserPlaylistGenreAffinity';
+import type { UserArtistAffinity, UserArtistAffinityId } from './UserArtistAffinity';
+import type { UserGenreAffinity, UserGenreAffinityId } from './UserGenreAffinity';
+
+export interface AffinityTierAttributes {
+  id: number;
+  name: string;
+}
+
+export type AffinityTierPk = "id";
+export type AffinityTierId = AffinityTier[AffinityTierPk];
+export type AffinityTierCreationAttributes = AffinityTierAttributes;
+
+export class AffinityTier extends Model<AffinityTierAttributes, AffinityTierCreationAttributes> implements AffinityTierAttributes {
+  id!: number;
+  name!: string;
+
+  // AffinityTier hasMany JukeboxSessionArtistAffinity via affinityTierId
+  jukeboxSessionArtistAffinities!: JukeboxSessionArtistAffinity[];
+  getJukeboxSessionArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionArtistAffinity>;
+  setJukeboxSessionArtistAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  addJukeboxSessionArtistAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  addJukeboxSessionArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  createJukeboxSessionArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionArtistAffinity>;
+  removeJukeboxSessionArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  removeJukeboxSessionArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  hasJukeboxSessionArtistAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  hasJukeboxSessionArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionArtistAffinity, JukeboxSessionArtistAffinityId>;
+  countJukeboxSessionArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany JukeboxSessionGenreAffinity via affinityTierId
+  jukeboxSessionGenreAffinities!: JukeboxSessionGenreAffinity[];
+  getJukeboxSessionGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<JukeboxSessionGenreAffinity>;
+  setJukeboxSessionGenreAffinities!: Sequelize.HasManySetAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  addJukeboxSessionGenreAffinity!: Sequelize.HasManyAddAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  addJukeboxSessionGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  createJukeboxSessionGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<JukeboxSessionGenreAffinity>;
+  removeJukeboxSessionGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  removeJukeboxSessionGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  hasJukeboxSessionGenreAffinity!: Sequelize.HasManyHasAssociationMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  hasJukeboxSessionGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<JukeboxSessionGenreAffinity, JukeboxSessionGenreAffinityId>;
+  countJukeboxSessionGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany PlatformUserPlaylistArtistAffinity via affinityTierId
+  platformUserPlaylistArtistAffinities!: PlatformUserPlaylistArtistAffinity[];
+  getPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistArtistAffinity>;
+  setPlatformUserPlaylistArtistAffinities!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  addPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  addPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  createPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistArtistAffinity>;
+  removePlatformUserPlaylistArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  removePlatformUserPlaylistArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  hasPlatformUserPlaylistArtistAffinity!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  hasPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistArtistAffinity, PlatformUserPlaylistArtistAffinityId>;
+  countPlatformUserPlaylistArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany PlatformUserPlaylistGenreAffinity via affinityTierId
+  platformUserPlaylistGenreAffinities!: PlatformUserPlaylistGenreAffinity[];
+  getPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<PlatformUserPlaylistGenreAffinity>;
+  setPlatformUserPlaylistGenreAffinities!: Sequelize.HasManySetAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  addPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyAddAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  addPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  createPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<PlatformUserPlaylistGenreAffinity>;
+  removePlatformUserPlaylistGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  removePlatformUserPlaylistGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  hasPlatformUserPlaylistGenreAffinity!: Sequelize.HasManyHasAssociationMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  hasPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<PlatformUserPlaylistGenreAffinity, PlatformUserPlaylistGenreAffinityId>;
+  countPlatformUserPlaylistGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany UserArtistAffinity via affinityTierId
+  userArtistAffinities!: UserArtistAffinity[];
+  getUserArtistAffinities!: Sequelize.HasManyGetAssociationsMixin<UserArtistAffinity>;
+  setUserArtistAffinities!: Sequelize.HasManySetAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinity!: Sequelize.HasManyAddAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  addUserArtistAffinities!: Sequelize.HasManyAddAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  createUserArtistAffinity!: Sequelize.HasManyCreateAssociationMixin<UserArtistAffinity>;
+  removeUserArtistAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  removeUserArtistAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinity!: Sequelize.HasManyHasAssociationMixin<UserArtistAffinity, UserArtistAffinityId>;
+  hasUserArtistAffinities!: Sequelize.HasManyHasAssociationsMixin<UserArtistAffinity, UserArtistAffinityId>;
+  countUserArtistAffinities!: Sequelize.HasManyCountAssociationsMixin;
+  // AffinityTier hasMany UserGenreAffinity via affinityTierId
+  userGenreAffinities!: UserGenreAffinity[];
+  getUserGenreAffinities!: Sequelize.HasManyGetAssociationsMixin<UserGenreAffinity>;
+  setUserGenreAffinities!: Sequelize.HasManySetAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinity!: Sequelize.HasManyAddAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  addUserGenreAffinities!: Sequelize.HasManyAddAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  createUserGenreAffinity!: Sequelize.HasManyCreateAssociationMixin<UserGenreAffinity>;
+  removeUserGenreAffinity!: Sequelize.HasManyRemoveAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  removeUserGenreAffinities!: Sequelize.HasManyRemoveAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinity!: Sequelize.HasManyHasAssociationMixin<UserGenreAffinity, UserGenreAffinityId>;
+  hasUserGenreAffinities!: Sequelize.HasManyHasAssociationsMixin<UserGenreAffinity, UserGenreAffinityId>;
+  countUserGenreAffinities!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof AffinityTier {
+    return AffinityTier.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(32),
+      allowNull: false,
+      unique: "affinity_tier_name_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'affinity_tier',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "affinity_tier_name_unique",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "affinity_tier_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}