@earbug/db-models 0.0.62 → 0.0.63

package/models/VersusQuestion.ts

@@ -0,0 +1,123 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Versus, VersusId } from './Versus';
+import type { VersusQuestionVariableType, VersusQuestionVariableTypeId } from './VersusQuestionVariableType';
+import type { VersusVotingListType, VersusVotingListTypeId } from './VersusVotingListType';
+
+export interface VersusQuestionAttributes {
+  id: string;
+  questionTemplate: string;
+  questionVariableTypeId: number;
+  votingListTypeId: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type VersusQuestionPk = "id";
+export type VersusQuestionId = VersusQuestion[VersusQuestionPk];
+export type VersusQuestionOptionalAttributes = "id" | "createdAt" | "updatedAt";
+export type VersusQuestionCreationAttributes = Optional<VersusQuestionAttributes, VersusQuestionOptionalAttributes>;
+
+export class VersusQuestion extends Model<VersusQuestionAttributes, VersusQuestionCreationAttributes> implements VersusQuestionAttributes {
+  id!: string;
+  questionTemplate!: string;
+  questionVariableTypeId!: number;
+  votingListTypeId!: number;
+  createdAt!: Date;
+  updatedAt!: Date;
+
+  // VersusQuestion hasMany Versus via versusQuestionId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+  // VersusQuestion belongsTo VersusQuestionVariableType via questionVariableTypeId
+  questionVariableType!: VersusQuestionVariableType;
+  getQuestionVariableType!: Sequelize.BelongsToGetAssociationMixin<VersusQuestionVariableType>;
+  setQuestionVariableType!: Sequelize.BelongsToSetAssociationMixin<VersusQuestionVariableType, VersusQuestionVariableTypeId>;
+  createQuestionVariableType!: Sequelize.BelongsToCreateAssociationMixin<VersusQuestionVariableType>;
+  // VersusQuestion belongsTo VersusVotingListType via votingListTypeId
+  votingListType!: VersusVotingListType;
+  getVotingListType!: Sequelize.BelongsToGetAssociationMixin<VersusVotingListType>;
+  setVotingListType!: Sequelize.BelongsToSetAssociationMixin<VersusVotingListType, VersusVotingListTypeId>;
+  createVotingListType!: Sequelize.BelongsToCreateAssociationMixin<VersusVotingListType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusQuestion {
+    return VersusQuestion.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    questionTemplate: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'question_template'
+    },
+    questionVariableTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'versus_question_variable_type',
+        key: 'id'
+      },
+      field: 'question_variable_type_id'
+    },
+    votingListTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      references: {
+        model: 'versus_voting_list_type',
+        key: 'id'
+      },
+      field: 'voting_list_type_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    updatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'updated_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_question',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_versus_question_variable_type",
+        fields: [
+          { name: "question_variable_type_id" },
+        ]
+      },
+      {
+        name: "idx_versus_question_voting_list",
+        fields: [
+          { name: "voting_list_type_id" },
+        ]
+      },
+      {
+        name: "versus_question_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusQuestionVariableType.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { VersusQuestion, VersusQuestionId } from './VersusQuestion';
+
+export interface VersusQuestionVariableTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type VersusQuestionVariableTypePk = "id";
+export type VersusQuestionVariableTypeId = VersusQuestionVariableType[VersusQuestionVariableTypePk];
+export type VersusQuestionVariableTypeCreationAttributes = VersusQuestionVariableTypeAttributes;
+
+export class VersusQuestionVariableType extends Model<VersusQuestionVariableTypeAttributes, VersusQuestionVariableTypeCreationAttributes> implements VersusQuestionVariableTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // VersusQuestionVariableType hasMany VersusQuestion via questionVariableTypeId
+  versusQuestions!: VersusQuestion[];
+  getVersusQuestions!: Sequelize.HasManyGetAssociationsMixin<VersusQuestion>;
+  setVersusQuestions!: Sequelize.HasManySetAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestion!: Sequelize.HasManyAddAssociationMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestions!: Sequelize.HasManyAddAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  createVersusQuestion!: Sequelize.HasManyCreateAssociationMixin<VersusQuestion>;
+  removeVersusQuestion!: Sequelize.HasManyRemoveAssociationMixin<VersusQuestion, VersusQuestionId>;
+  removeVersusQuestions!: Sequelize.HasManyRemoveAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestion!: Sequelize.HasManyHasAssociationMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestions!: Sequelize.HasManyHasAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  countVersusQuestions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusQuestionVariableType {
+    return VersusQuestionVariableType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(64),
+      allowNull: false,
+      unique: "versus_question_variable_type_description_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_question_variable_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "versus_question_variable_type_description_unique",
+        unique: true,
+        fields: [
+          { name: "description" },
+        ]
+      },
+      {
+        name: "versus_question_variable_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusVote.ts

@@ -0,0 +1,99 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { Versus, VersusId } from './Versus';
+
+export interface VersusVoteAttributes {
+  id: string;
+  versusId: string;
+  appUserId: string;
+  createdAt: Date;
+}
+
+export type VersusVotePk = "id";
+export type VersusVoteId = VersusVote[VersusVotePk];
+export type VersusVoteOptionalAttributes = "id" | "createdAt";
+export type VersusVoteCreationAttributes = Optional<VersusVoteAttributes, VersusVoteOptionalAttributes>;
+
+export class VersusVote extends Model<VersusVoteAttributes, VersusVoteCreationAttributes> implements VersusVoteAttributes {
+  id!: string;
+  versusId!: string;
+  appUserId!: string;
+  createdAt!: Date;
+
+  // VersusVote belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // VersusVote belongsTo Versus via versusId
+  versu!: Versus;
+  getVersu!: Sequelize.BelongsToGetAssociationMixin<Versus>;
+  setVersu!: Sequelize.BelongsToSetAssociationMixin<Versus, VersusId>;
+  createVersu!: Sequelize.BelongsToCreateAssociationMixin<Versus>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusVote {
+    return VersusVote.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    versusId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'versus',
+        key: 'id'
+      },
+      unique: "uq_versus_vote_versus_app_user",
+      field: 'versus_id'
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "uq_versus_vote_versus_app_user",
+      field: 'app_user_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_vote',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "idx_versus_vote_versus",
+        fields: [
+          { name: "versus_id" },
+        ]
+      },
+      {
+        name: "uq_versus_vote_versus_app_user",
+        unique: true,
+        fields: [
+          { name: "versus_id" },
+          { name: "app_user_id" },
+        ]
+      },
+      {
+        name: "versus_vote_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusVotingListType.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { VersusQuestion, VersusQuestionId } from './VersusQuestion';
+
+export interface VersusVotingListTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type VersusVotingListTypePk = "id";
+export type VersusVotingListTypeId = VersusVotingListType[VersusVotingListTypePk];
+export type VersusVotingListTypeCreationAttributes = VersusVotingListTypeAttributes;
+
+export class VersusVotingListType extends Model<VersusVotingListTypeAttributes, VersusVotingListTypeCreationAttributes> implements VersusVotingListTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // VersusVotingListType hasMany VersusQuestion via votingListTypeId
+  versusQuestions!: VersusQuestion[];
+  getVersusQuestions!: Sequelize.HasManyGetAssociationsMixin<VersusQuestion>;
+  setVersusQuestions!: Sequelize.HasManySetAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestion!: Sequelize.HasManyAddAssociationMixin<VersusQuestion, VersusQuestionId>;
+  addVersusQuestions!: Sequelize.HasManyAddAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  createVersusQuestion!: Sequelize.HasManyCreateAssociationMixin<VersusQuestion>;
+  removeVersusQuestion!: Sequelize.HasManyRemoveAssociationMixin<VersusQuestion, VersusQuestionId>;
+  removeVersusQuestions!: Sequelize.HasManyRemoveAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestion!: Sequelize.HasManyHasAssociationMixin<VersusQuestion, VersusQuestionId>;
+  hasVersusQuestions!: Sequelize.HasManyHasAssociationsMixin<VersusQuestion, VersusQuestionId>;
+  countVersusQuestions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusVotingListType {
+    return VersusVotingListType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(64),
+      allowNull: false,
+      unique: "versus_voting_list_type_description_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_voting_list_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "versus_voting_list_type_description_unique",
+        unique: true,
+        fields: [
+          { name: "description" },
+        ]
+      },
+      {
+        name: "versus_voting_list_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/VersusVotingMode.ts

@@ -0,0 +1,66 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { Versus, VersusId } from './Versus';
+
+export interface VersusVotingModeAttributes {
+  id: number;
+  description: string;
+}
+
+export type VersusVotingModePk = "id";
+export type VersusVotingModeId = VersusVotingMode[VersusVotingModePk];
+export type VersusVotingModeCreationAttributes = VersusVotingModeAttributes;
+
+export class VersusVotingMode extends Model<VersusVotingModeAttributes, VersusVotingModeCreationAttributes> implements VersusVotingModeAttributes {
+  id!: number;
+  description!: string;
+
+  // VersusVotingMode hasMany Versus via versusVotingModeId
+  versus!: Versus[];
+  getVersus!: Sequelize.HasManyGetAssociationsMixin<Versus>;
+  setVersus!: Sequelize.HasManySetAssociationsMixin<Versus, VersusId>;
+  addVersu!: Sequelize.HasManyAddAssociationMixin<Versus, VersusId>;
+  addVersus!: Sequelize.HasManyAddAssociationsMixin<Versus, VersusId>;
+  createVersu!: Sequelize.HasManyCreateAssociationMixin<Versus>;
+  removeVersu!: Sequelize.HasManyRemoveAssociationMixin<Versus, VersusId>;
+  removeVersus!: Sequelize.HasManyRemoveAssociationsMixin<Versus, VersusId>;
+  hasVersu!: Sequelize.HasManyHasAssociationMixin<Versus, VersusId>;
+  hasVersus!: Sequelize.HasManyHasAssociationsMixin<Versus, VersusId>;
+  countVersus!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof VersusVotingMode {
+    return VersusVotingMode.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(64),
+      allowNull: false,
+      unique: "versus_voting_mode_description_unique"
+    }
+  }, {
+    sequelize,
+    tableName: 'versus_voting_mode',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "versus_voting_mode_description_unique",
+        unique: true,
+        fields: [
+          { name: "description" },
+        ]
+      },
+      {
+        name: "versus_voting_mode_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/index.ts

@@ -0,0 +1,3 @@
+export * from "./init-models";
+export { initDb, RDS_SSL_CONFIG } from "./initDb";
+export type { InitDbOptions } from "./initDb";