@earbug/db-models 0.0.1

package/models/JukeboxTerminationCondition.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxTerminationConditionAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxTerminationConditionPk = "id";
+export type JukeboxTerminationConditionId = JukeboxTerminationCondition[JukeboxTerminationConditionPk];
+export type JukeboxTerminationConditionCreationAttributes = JukeboxTerminationConditionAttributes;
+
+export class JukeboxTerminationCondition extends Model<JukeboxTerminationConditionAttributes, JukeboxTerminationConditionCreationAttributes> implements JukeboxTerminationConditionAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxTerminationCondition hasMany JukeboxSession via terminationConditionId
+  jukeboxSessions!: JukeboxSession[];
+  getJukeboxSessions!: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+  setJukeboxSessions!: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSession!: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSessions!: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+  removeJukeboxSession!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  removeJukeboxSessions!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSession!: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSessions!: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  countJukeboxSessions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxTerminationCondition {
+    return JukeboxTerminationCondition.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_termination_condition',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_termination_condition_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxType.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+
+export interface JukeboxTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxTypePk = "id";
+export type JukeboxTypeId = JukeboxType[JukeboxTypePk];
+export type JukeboxTypeCreationAttributes = JukeboxTypeAttributes;
+
+export class JukeboxType extends Model<JukeboxTypeAttributes, JukeboxTypeCreationAttributes> implements JukeboxTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxType hasMany JukeboxSession via typeId
+  jukeboxSessions!: JukeboxSession[];
+  getJukeboxSessions!: Sequelize.HasManyGetAssociationsMixin<JukeboxSession>;
+  setJukeboxSessions!: Sequelize.HasManySetAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSession!: Sequelize.HasManyAddAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  addJukeboxSessions!: Sequelize.HasManyAddAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.HasManyCreateAssociationMixin<JukeboxSession>;
+  removeJukeboxSession!: Sequelize.HasManyRemoveAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  removeJukeboxSessions!: Sequelize.HasManyRemoveAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSession!: Sequelize.HasManyHasAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  hasJukeboxSessions!: Sequelize.HasManyHasAssociationsMixin<JukeboxSession, JukeboxSessionId>;
+  countJukeboxSessions!: Sequelize.HasManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxType {
+    return JukeboxType.init({
+    id: {
+      autoIncrement: true,
+      autoIncrementIdentity: true,
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxUser.ts

@@ -0,0 +1,169 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { AppUser, AppUserId } from './AppUser';
+import type { JukeboxQueueEntry, JukeboxQueueEntryId } from './JukeboxQueueEntry';
+import type { JukeboxSession, JukeboxSessionId } from './JukeboxSession';
+import type { JukeboxUserType, JukeboxUserTypeId } from './JukeboxUserType';
+import type { PauseStatusType, PauseStatusTypeId } from './PauseStatusType';
+
+export interface JukeboxUserAttributes {
+  id: string;
+  jukeboxSessionId: string;
+  appUserId: string;
+  createdAt: Date;
+  updatedAt: Date;
+  enterDate: Date;
+  exitDate?: Date;
+  jukeboxUserTypeId: number;
+  pauseStatusTypeId: number;
+  pausedQueueEntryId?: string;
+}
+
+export type JukeboxUserPk = "id";
+export type JukeboxUserId = JukeboxUser[JukeboxUserPk];
+export type JukeboxUserOptionalAttributes = "id" | "createdAt" | "updatedAt" | "enterDate" | "exitDate" | "jukeboxUserTypeId" | "pauseStatusTypeId" | "pausedQueueEntryId";
+export type JukeboxUserCreationAttributes = Optional<JukeboxUserAttributes, JukeboxUserOptionalAttributes>;
+
+export class JukeboxUser extends Model<JukeboxUserAttributes, JukeboxUserCreationAttributes> implements JukeboxUserAttributes {
+  id!: string;
+  jukeboxSessionId!: string;
+  appUserId!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  enterDate!: Date;
+  exitDate?: Date;
+  jukeboxUserTypeId!: number;
+  pauseStatusTypeId!: number;
+  pausedQueueEntryId?: string;
+
+  // JukeboxUser belongsTo AppUser via appUserId
+  appUser!: AppUser;
+  getAppUser!: Sequelize.BelongsToGetAssociationMixin<AppUser>;
+  setAppUser!: Sequelize.BelongsToSetAssociationMixin<AppUser, AppUserId>;
+  createAppUser!: Sequelize.BelongsToCreateAssociationMixin<AppUser>;
+  // JukeboxUser belongsTo JukeboxQueueEntry via pausedQueueEntryId
+  pausedQueueEntry!: JukeboxQueueEntry;
+  getPausedQueueEntry!: Sequelize.BelongsToGetAssociationMixin<JukeboxQueueEntry>;
+  setPausedQueueEntry!: Sequelize.BelongsToSetAssociationMixin<JukeboxQueueEntry, JukeboxQueueEntryId>;
+  createPausedQueueEntry!: Sequelize.BelongsToCreateAssociationMixin<JukeboxQueueEntry>;
+  // JukeboxUser belongsTo JukeboxSession via jukeboxSessionId
+  jukeboxSession!: JukeboxSession;
+  getJukeboxSession!: Sequelize.BelongsToGetAssociationMixin<JukeboxSession>;
+  setJukeboxSession!: Sequelize.BelongsToSetAssociationMixin<JukeboxSession, JukeboxSessionId>;
+  createJukeboxSession!: Sequelize.BelongsToCreateAssociationMixin<JukeboxSession>;
+  // JukeboxUser belongsTo JukeboxUserType via jukeboxUserTypeId
+  jukeboxUserType!: JukeboxUserType;
+  getJukeboxUserType!: Sequelize.BelongsToGetAssociationMixin<JukeboxUserType>;
+  setJukeboxUserType!: Sequelize.BelongsToSetAssociationMixin<JukeboxUserType, JukeboxUserTypeId>;
+  createJukeboxUserType!: Sequelize.BelongsToCreateAssociationMixin<JukeboxUserType>;
+  // JukeboxUser belongsTo PauseStatusType via pauseStatusTypeId
+  pauseStatusType!: PauseStatusType;
+  getPauseStatusType!: Sequelize.BelongsToGetAssociationMixin<PauseStatusType>;
+  setPauseStatusType!: Sequelize.BelongsToSetAssociationMixin<PauseStatusType, PauseStatusTypeId>;
+  createPauseStatusType!: Sequelize.BelongsToCreateAssociationMixin<PauseStatusType>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxUser {
+    return JukeboxUser.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true
+    },
+    jukeboxSessionId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'jukebox_session',
+        key: 'id'
+      },
+      unique: "unique_jukebox_user_id",
+      field: 'jukebox_session_id'
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'app_user',
+        key: 'id'
+      },
+      unique: "unique_jukebox_user_id",
+      field: 'app_user_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'
+    },
+    enterDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'enter_date'
+    },
+    exitDate: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'exit_date'
+    },
+    jukeboxUserTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'jukebox_user_type',
+        key: 'id'
+      },
+      field: 'jukebox_user_type_id'
+    },
+    pauseStatusTypeId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      defaultValue: 0,
+      references: {
+        model: 'pause_status_type',
+        key: 'id'
+      },
+      field: 'pause_status_type_id'
+    },
+    pausedQueueEntryId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      references: {
+        model: 'jukebox_queue_entry',
+        key: 'id'
+      },
+      field: 'paused_queue_entry_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_user',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_user_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+      {
+        name: "unique_jukebox_user_id",
+        unique: true,
+        fields: [
+          { name: "jukebox_session_id" },
+          { name: "app_user_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/JukeboxUserType.ts

@@ -0,0 +1,58 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { JukeboxUser, JukeboxUserId } from './JukeboxUser';
+
+export interface JukeboxUserTypeAttributes {
+  id: number;
+  description: string;
+}
+
+export type JukeboxUserTypePk = "id";
+export type JukeboxUserTypeId = JukeboxUserType[JukeboxUserTypePk];
+export type JukeboxUserTypeCreationAttributes = JukeboxUserTypeAttributes;
+
+export class JukeboxUserType extends Model<JukeboxUserTypeAttributes, JukeboxUserTypeCreationAttributes> implements JukeboxUserTypeAttributes {
+  id!: number;
+  description!: string;
+
+  // JukeboxUserType hasMany JukeboxUser via jukeboxUserTypeId
+  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;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof JukeboxUserType {
+    return JukeboxUserType.init({
+    id: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      primaryKey: true
+    },
+    description: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    }
+  }, {
+    sequelize,
+    tableName: 'jukebox_user_type',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "jukebox_user_type_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/KnexMigrations.ts

@@ -0,0 +1,60 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface KnexMigrationsAttributes {
+  id: number;
+  name?: string;
+  batch?: number;
+  migrationTime?: Date;
+}
+
+export type KnexMigrationsPk = "id";
+export type KnexMigrationsId = KnexMigrations[KnexMigrationsPk];
+export type KnexMigrationsOptionalAttributes = "id" | "name" | "batch" | "migrationTime";
+export type KnexMigrationsCreationAttributes = Optional<KnexMigrationsAttributes, KnexMigrationsOptionalAttributes>;
+
+export class KnexMigrations extends Model<KnexMigrationsAttributes, KnexMigrationsCreationAttributes> implements KnexMigrationsAttributes {
+  id!: number;
+  name?: string;
+  batch?: number;
+  migrationTime?: Date;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof KnexMigrations {
+    return KnexMigrations.init({
+    id: {
+      autoIncrement: true,
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.STRING(255),
+      allowNull: true
+    },
+    batch: {
+      type: DataTypes.INTEGER,
+      allowNull: true
+    },
+    migrationTime: {
+      type: DataTypes.DATE,
+      allowNull: true,
+      field: 'migration_time'
+    }
+  }, {
+    sequelize,
+    tableName: 'knex_migrations',
+    schema: 'public',
+    timestamps: false,
+    indexes: [
+      {
+        name: "knex_migrations_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/KnexMigrationsLock.ts

@@ -0,0 +1,48 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface KnexMigrationsLockAttributes {
+  index: number;
+  isLocked?: number;
+}
+
+export type KnexMigrationsLockPk = "index";
+export type KnexMigrationsLockId = KnexMigrationsLock[KnexMigrationsLockPk];
+export type KnexMigrationsLockOptionalAttributes = "index" | "isLocked";
+export type KnexMigrationsLockCreationAttributes = Optional<KnexMigrationsLockAttributes, KnexMigrationsLockOptionalAttributes>;
+
+export class KnexMigrationsLock extends Model<KnexMigrationsLockAttributes, KnexMigrationsLockCreationAttributes> implements KnexMigrationsLockAttributes {
+  index!: number;
+  isLocked?: number;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof KnexMigrationsLock {
+    return KnexMigrationsLock.init({
+    index: {
+      autoIncrement: true,
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      primaryKey: true
+    },
+    isLocked: {
+      type: DataTypes.INTEGER,
+      allowNull: true,
+      field: 'is_locked'
+    }
+  }, {
+    sequelize,
+    tableName: 'knex_migrations_lock',
+    schema: 'public',
+    timestamps: false,
+    indexes: [
+      {
+        name: "knex_migrations_lock_pkey",
+        unique: true,
+        fields: [
+          { name: "index" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/MetricsDaily.ts

@@ -0,0 +1,79 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface MetricsDailyAttributes {
+  day?: string;
+  eventType: string;
+  createdAt: Date;
+  updatedAt: Date;
+  metrics?: object;
+}
+
+export type MetricsDailyOptionalAttributes = "day" | "createdAt" | "updatedAt" | "metrics";
+export type MetricsDailyCreationAttributes = Optional<MetricsDailyAttributes, MetricsDailyOptionalAttributes>;
+
+export class MetricsDaily extends Model<MetricsDailyAttributes, MetricsDailyCreationAttributes> implements MetricsDailyAttributes {
+  day?: string;
+  eventType!: string;
+  createdAt!: Date;
+  updatedAt!: Date;
+  metrics?: object;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof MetricsDaily {
+    return MetricsDaily.init({
+    day: {
+      type: DataTypes.DATEONLY,
+      allowNull: true
+    },
+    eventType: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'event_type'
+    },
+    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'
+    },
+    metrics: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    }
+  }, {
+    sequelize,
+    tableName: 'metrics_daily',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "metrics_daily_day_event_type_unique",
+        unique: true,
+        fields: [
+          { name: "day" },
+          { name: "event_type" },
+        ]
+      },
+      {
+        name: "metrics_daily_event_type_index",
+        fields: [
+          { name: "event_type" },
+        ]
+      },
+      {
+        name: "metricsdaily_day_idx",
+        fields: [
+          { name: "day" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/MetricsEvent.ts

@@ -0,0 +1,114 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+
+export interface MetricsEventAttributes {
+  eventType: string;
+  appUserId: string;
+  sessionId: string;
+  devicePlatformId: number;
+  createdAt: Date;
+  meta?: object;
+  objectId?: string;
+}
+
+export type MetricsEventOptionalAttributes = "createdAt" | "meta" | "objectId";
+export type MetricsEventCreationAttributes = Optional<MetricsEventAttributes, MetricsEventOptionalAttributes>;
+
+export class MetricsEvent extends Model<MetricsEventAttributes, MetricsEventCreationAttributes> implements MetricsEventAttributes {
+  eventType!: string;
+  appUserId!: string;
+  sessionId!: string;
+  devicePlatformId!: number;
+  createdAt!: Date;
+  meta?: object;
+  objectId?: string;
+
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof MetricsEvent {
+    return MetricsEvent.init({
+    eventType: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'event_type'
+    },
+    appUserId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      field: 'app_user_id'
+    },
+    sessionId: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'session_id'
+    },
+    devicePlatformId: {
+      type: DataTypes.SMALLINT,
+      allowNull: false,
+      field: 'device_platform_id'
+    },
+    createdAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'created_at'
+    },
+    meta: {
+      type: DataTypes.JSONB,
+      allowNull: true
+    },
+    objectId: {
+      type: DataTypes.UUID,
+      allowNull: true,
+      field: 'object_id'
+    }
+  }, {
+    sequelize,
+    tableName: 'metrics_event',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "metrics_created_idx",
+        fields: [
+          { name: "created_at" },
+        ]
+      },
+      {
+        name: "metrics_dev_plat_idx",
+        fields: [
+          { name: "device_platform_id" },
+        ]
+      },
+      {
+        name: "metrics_object_idx",
+        fields: [
+          { name: "object_id" },
+        ]
+      },
+      {
+        name: "metrics_session_idx",
+        fields: [
+          { name: "session_id" },
+        ]
+      },
+      {
+        name: "metrics_status_idx",
+        fields: [
+        ]
+      },
+      {
+        name: "metrics_type_idx",
+        fields: [
+          { name: "event_type" },
+        ]
+      },
+      {
+        name: "metrics_user_idx",
+        fields: [
+          { name: "app_user_id" },
+        ]
+      },
+    ]
+  });
+  }
+}