@earbug/db-models 0.0.62 → 0.0.63

package/models/CanonLabel.ts

@@ -0,0 +1,129 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbumLabelRelation, CanonAlbumLabelRelationId } from './CanonAlbumLabelRelation';
+import type { CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId } from './CanonLabelExternalReferenceRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface CanonLabelAttributes {
+  id: string;
+  name: string;
+  asciiName: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonLabelPk = "id";
+export type CanonLabelId = CanonLabel[CanonLabelPk];
+export type CanonLabelOptionalAttributes = "id" | "createDate" | "updateDate";
+export type CanonLabelCreationAttributes = Optional<CanonLabelAttributes, CanonLabelOptionalAttributes>;
+
+export class CanonLabel extends Model<CanonLabelAttributes, CanonLabelCreationAttributes> implements CanonLabelAttributes {
+  id!: string;
+  name!: string;
+  asciiName!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonLabel hasMany CanonAlbumLabelRelation via canonLabelId
+  canonAlbumLabelRelations!: CanonAlbumLabelRelation[];
+  getCanonAlbumLabelRelations!: Sequelize.HasManyGetAssociationsMixin<CanonAlbumLabelRelation>;
+  setCanonAlbumLabelRelations!: Sequelize.HasManySetAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  addCanonAlbumLabelRelation!: Sequelize.HasManyAddAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  addCanonAlbumLabelRelations!: Sequelize.HasManyAddAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  createCanonAlbumLabelRelation!: Sequelize.HasManyCreateAssociationMixin<CanonAlbumLabelRelation>;
+  removeCanonAlbumLabelRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  removeCanonAlbumLabelRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  hasCanonAlbumLabelRelation!: Sequelize.HasManyHasAssociationMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  hasCanonAlbumLabelRelations!: Sequelize.HasManyHasAssociationsMixin<CanonAlbumLabelRelation, CanonAlbumLabelRelationId>;
+  countCanonAlbumLabelRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonLabel hasMany CanonLabelExternalReferenceRelation via canonLabelId
+  canonLabelExternalReferenceRelations!: CanonLabelExternalReferenceRelation[];
+  getCanonLabelExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonLabelExternalReferenceRelation>;
+  setCanonLabelExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  addCanonLabelExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  addCanonLabelExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  createCanonLabelExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonLabelExternalReferenceRelation>;
+  removeCanonLabelExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  removeCanonLabelExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  hasCanonLabelExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  hasCanonLabelExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonLabelExternalReferenceRelation, CanonLabelExternalReferenceRelationId>;
+  countCanonLabelExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonLabel belongsToMany ExternalReference via canonLabelId and externalReferenceId
+  externalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: ExternalReference[];
+  getExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+  setExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+  removeExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+  removeExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  countExternalReferenceIdExternalReferenceCanonLabelExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonLabel belongsToMany PlatformAlbum via canonLabelId and canonAlbumId
+  canonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: PlatformAlbum[];
+  getCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformAlbum>;
+  setCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  addCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  createCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformAlbum>;
+  removeCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  removeCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbumCanonAlbumLabelRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  hasCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformAlbum, PlatformAlbumId>;
+  countCanonAlbumIdPlatformAlbumCanonAlbumLabelRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonLabel {
+    return CanonLabel.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: false,
+      field: 'ascii_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'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_label',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "label_name_idx",
+        unique: true,
+        fields: [
+          { name: "name" },
+        ]
+      },
+      {
+        name: "label_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonLabelExternalReferenceRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonLabel, CanonLabelId } from './CanonLabel';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+
+export interface CanonLabelExternalReferenceRelationAttributes {
+  canonLabelId: string;
+  externalReferenceId: string;
+  url: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonLabelExternalReferenceRelationPk = "canonLabelId" | "externalReferenceId";
+export type CanonLabelExternalReferenceRelationId = CanonLabelExternalReferenceRelation[CanonLabelExternalReferenceRelationPk];
+export type CanonLabelExternalReferenceRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonLabelExternalReferenceRelationCreationAttributes = Optional<CanonLabelExternalReferenceRelationAttributes, CanonLabelExternalReferenceRelationOptionalAttributes>;
+
+export class CanonLabelExternalReferenceRelation extends Model<CanonLabelExternalReferenceRelationAttributes, CanonLabelExternalReferenceRelationCreationAttributes> implements CanonLabelExternalReferenceRelationAttributes {
+  canonLabelId!: string;
+  externalReferenceId!: string;
+  url!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonLabelExternalReferenceRelation belongsTo CanonLabel via canonLabelId
+  canonLabel!: CanonLabel;
+  getCanonLabel!: Sequelize.BelongsToGetAssociationMixin<CanonLabel>;
+  setCanonLabel!: Sequelize.BelongsToSetAssociationMixin<CanonLabel, CanonLabelId>;
+  createCanonLabel!: Sequelize.BelongsToCreateAssociationMixin<CanonLabel>;
+  // CanonLabelExternalReferenceRelation belongsTo ExternalReference via externalReferenceId
+  externalReference!: ExternalReference;
+  getExternalReference!: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+  setExternalReference!: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReference!: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonLabelExternalReferenceRelation {
+    return CanonLabelExternalReferenceRelation.init({
+    canonLabelId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_label',
+        key: 'id'
+      },
+      field: 'canon_label_id'
+    },
+    externalReferenceId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'external_reference',
+        key: 'id'
+      },
+      field: 'external_reference_id'
+    },
+    url: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_label_external_reference_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_label_external_reference_relation_pk",
+        unique: true,
+        fields: [
+          { name: "canon_label_id" },
+          { name: "external_reference_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonMember.ts

@@ -0,0 +1,130 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtistMemberRelation, CanonArtistMemberRelationId } from './CanonArtistMemberRelation';
+import type { CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId } from './CanonMemberExternalReferenceRelation';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+
+export interface CanonMemberAttributes {
+  id: string;
+  name?: string;
+  asciiName?: string;
+  createDate?: Date;
+  updateDate?: Date;
+  isPast?: boolean;
+}
+
+export type CanonMemberPk = "id";
+export type CanonMemberId = CanonMember[CanonMemberPk];
+export type CanonMemberOptionalAttributes = "id" | "name" | "asciiName" | "createDate" | "updateDate" | "isPast";
+export type CanonMemberCreationAttributes = Optional<CanonMemberAttributes, CanonMemberOptionalAttributes>;
+
+export class CanonMember extends Model<CanonMemberAttributes, CanonMemberCreationAttributes> implements CanonMemberAttributes {
+  id!: string;
+  name?: string;
+  asciiName?: string;
+  createDate?: Date;
+  updateDate?: Date;
+  isPast?: boolean;
+
+  // CanonMember hasMany CanonArtistMemberRelation via canonMemberId
+  canonArtistMemberRelations!: CanonArtistMemberRelation[];
+  getCanonArtistMemberRelations!: Sequelize.HasManyGetAssociationsMixin<CanonArtistMemberRelation>;
+  setCanonArtistMemberRelations!: Sequelize.HasManySetAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  addCanonArtistMemberRelation!: Sequelize.HasManyAddAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  addCanonArtistMemberRelations!: Sequelize.HasManyAddAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  createCanonArtistMemberRelation!: Sequelize.HasManyCreateAssociationMixin<CanonArtistMemberRelation>;
+  removeCanonArtistMemberRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  removeCanonArtistMemberRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  hasCanonArtistMemberRelation!: Sequelize.HasManyHasAssociationMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  hasCanonArtistMemberRelations!: Sequelize.HasManyHasAssociationsMixin<CanonArtistMemberRelation, CanonArtistMemberRelationId>;
+  countCanonArtistMemberRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonMember hasMany CanonMemberExternalReferenceRelation via canonMemberId
+  canonMemberExternalReferenceRelations!: CanonMemberExternalReferenceRelation[];
+  getCanonMemberExternalReferenceRelations!: Sequelize.HasManyGetAssociationsMixin<CanonMemberExternalReferenceRelation>;
+  setCanonMemberExternalReferenceRelations!: Sequelize.HasManySetAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  addCanonMemberExternalReferenceRelation!: Sequelize.HasManyAddAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  addCanonMemberExternalReferenceRelations!: Sequelize.HasManyAddAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  createCanonMemberExternalReferenceRelation!: Sequelize.HasManyCreateAssociationMixin<CanonMemberExternalReferenceRelation>;
+  removeCanonMemberExternalReferenceRelation!: Sequelize.HasManyRemoveAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  removeCanonMemberExternalReferenceRelations!: Sequelize.HasManyRemoveAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  hasCanonMemberExternalReferenceRelation!: Sequelize.HasManyHasAssociationMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  hasCanonMemberExternalReferenceRelations!: Sequelize.HasManyHasAssociationsMixin<CanonMemberExternalReferenceRelation, CanonMemberExternalReferenceRelationId>;
+  countCanonMemberExternalReferenceRelations!: Sequelize.HasManyCountAssociationsMixin;
+  // CanonMember belongsToMany ExternalReference via canonMemberId and externalReferenceId
+  externalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations!: ExternalReference[];
+  getExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyGetAssociationsMixin<ExternalReference>;
+  setExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManySetAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyAddAssociationMixin<ExternalReference, ExternalReferenceId>;
+  addExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyAddAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyCreateAssociationMixin<ExternalReference>;
+  removeExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<ExternalReference, ExternalReferenceId>;
+  removeExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelation!: Sequelize.BelongsToManyHasAssociationMixin<ExternalReference, ExternalReferenceId>;
+  hasExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyHasAssociationsMixin<ExternalReference, ExternalReferenceId>;
+  countExternalReferenceIdExternalReferenceCanonMemberExternalReferenceRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+  // CanonMember belongsToMany PlatformArtist via canonMemberId and canonArtistId
+  canonArtistIdPlatformArtistCanonArtistMemberRelations!: PlatformArtist[];
+  getCanonArtistIdPlatformArtistCanonArtistMemberRelations!: Sequelize.BelongsToManyGetAssociationsMixin<PlatformArtist>;
+  setCanonArtistIdPlatformArtistCanonArtistMemberRelations!: Sequelize.BelongsToManySetAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  addCanonArtistIdPlatformArtistCanonArtistMemberRelation!: Sequelize.BelongsToManyAddAssociationMixin<PlatformArtist, PlatformArtistId>;
+  addCanonArtistIdPlatformArtistCanonArtistMemberRelations!: Sequelize.BelongsToManyAddAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  createCanonArtistIdPlatformArtistCanonArtistMemberRelation!: Sequelize.BelongsToManyCreateAssociationMixin<PlatformArtist>;
+  removeCanonArtistIdPlatformArtistCanonArtistMemberRelation!: Sequelize.BelongsToManyRemoveAssociationMixin<PlatformArtist, PlatformArtistId>;
+  removeCanonArtistIdPlatformArtistCanonArtistMemberRelations!: Sequelize.BelongsToManyRemoveAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  hasCanonArtistIdPlatformArtistCanonArtistMemberRelation!: Sequelize.BelongsToManyHasAssociationMixin<PlatformArtist, PlatformArtistId>;
+  hasCanonArtistIdPlatformArtistCanonArtistMemberRelations!: Sequelize.BelongsToManyHasAssociationsMixin<PlatformArtist, PlatformArtistId>;
+  countCanonArtistIdPlatformArtistCanonArtistMemberRelations!: Sequelize.BelongsToManyCountAssociationsMixin;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonMember {
+    return CanonMember.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1'),
+      primaryKey: true
+    },
+    name: {
+      type: DataTypes.TEXT,
+      allowNull: true
+    },
+    asciiName: {
+      type: DataTypes.TEXT,
+      allowNull: true,
+      field: 'ascii_name'
+    },
+    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'
+    },
+    isPast: {
+      type: DataTypes.BOOLEAN,
+      allowNull: true,
+      defaultValue: false,
+      field: 'is_past'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_member',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "member_pkey",
+        unique: true,
+        fields: [
+          { name: "id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonMemberExternalReferenceRelation.ts

@@ -0,0 +1,99 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonMember, CanonMemberId } from './CanonMember';
+import type { ExternalReference, ExternalReferenceId } from './ExternalReference';
+
+export interface CanonMemberExternalReferenceRelationAttributes {
+  id: string;
+  canonMemberId: string;
+  externalReferenceId: string;
+  url: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonMemberExternalReferenceRelationPk = "canonMemberId" | "externalReferenceId";
+export type CanonMemberExternalReferenceRelationId = CanonMemberExternalReferenceRelation[CanonMemberExternalReferenceRelationPk];
+export type CanonMemberExternalReferenceRelationOptionalAttributes = "id" | "createDate" | "updateDate";
+export type CanonMemberExternalReferenceRelationCreationAttributes = Optional<CanonMemberExternalReferenceRelationAttributes, CanonMemberExternalReferenceRelationOptionalAttributes>;
+
+export class CanonMemberExternalReferenceRelation extends Model<CanonMemberExternalReferenceRelationAttributes, CanonMemberExternalReferenceRelationCreationAttributes> implements CanonMemberExternalReferenceRelationAttributes {
+  id!: string;
+  canonMemberId!: string;
+  externalReferenceId!: string;
+  url!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonMemberExternalReferenceRelation belongsTo CanonMember via canonMemberId
+  canonMember!: CanonMember;
+  getCanonMember!: Sequelize.BelongsToGetAssociationMixin<CanonMember>;
+  setCanonMember!: Sequelize.BelongsToSetAssociationMixin<CanonMember, CanonMemberId>;
+  createCanonMember!: Sequelize.BelongsToCreateAssociationMixin<CanonMember>;
+  // CanonMemberExternalReferenceRelation belongsTo ExternalReference via externalReferenceId
+  externalReference!: ExternalReference;
+  getExternalReference!: Sequelize.BelongsToGetAssociationMixin<ExternalReference>;
+  setExternalReference!: Sequelize.BelongsToSetAssociationMixin<ExternalReference, ExternalReferenceId>;
+  createExternalReference!: Sequelize.BelongsToCreateAssociationMixin<ExternalReference>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonMemberExternalReferenceRelation {
+    return CanonMemberExternalReferenceRelation.init({
+    id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.fn('uuid_generate_v1')
+    },
+    canonMemberId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_member',
+        key: 'id'
+      },
+      field: 'canon_member_id'
+    },
+    externalReferenceId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'external_reference',
+        key: 'id'
+      },
+      field: 'external_reference_id'
+    },
+    url: {
+      type: DataTypes.TEXT,
+      allowNull: false
+    },
+    createDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'create_date'
+    },
+    updateDate: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: Sequelize.Sequelize.literal('CURRENT_TIMESTAMP'),
+      field: 'update_date'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_member_external_reference_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_member_external_reference_relation_pk",
+        unique: true,
+        fields: [
+          { name: "canon_member_id" },
+          { name: "external_reference_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonToPlatformAlbumRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonAlbum, CanonAlbumId } from './CanonAlbum';
+import type { PlatformAlbum, PlatformAlbumId } from './PlatformAlbum';
+
+export interface CanonToPlatformAlbumRelationAttributes {
+  canonAlbumId: string;
+  platformAlbumId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonToPlatformAlbumRelationPk = "canonAlbumId" | "platformAlbumId";
+export type CanonToPlatformAlbumRelationId = CanonToPlatformAlbumRelation[CanonToPlatformAlbumRelationPk];
+export type CanonToPlatformAlbumRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformAlbumRelationCreationAttributes = Optional<CanonToPlatformAlbumRelationAttributes, CanonToPlatformAlbumRelationOptionalAttributes>;
+
+export class CanonToPlatformAlbumRelation extends Model<CanonToPlatformAlbumRelationAttributes, CanonToPlatformAlbumRelationCreationAttributes> implements CanonToPlatformAlbumRelationAttributes {
+  canonAlbumId!: string;
+  platformAlbumId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonToPlatformAlbumRelation belongsTo CanonAlbum via canonAlbumId
+  canonAlbum!: CanonAlbum;
+  getCanonAlbum!: Sequelize.BelongsToGetAssociationMixin<CanonAlbum>;
+  setCanonAlbum!: Sequelize.BelongsToSetAssociationMixin<CanonAlbum, CanonAlbumId>;
+  createCanonAlbum!: Sequelize.BelongsToCreateAssociationMixin<CanonAlbum>;
+  // CanonToPlatformAlbumRelation belongsTo PlatformAlbum via platformAlbumId
+  platformAlbum!: PlatformAlbum;
+  getPlatformAlbum!: Sequelize.BelongsToGetAssociationMixin<PlatformAlbum>;
+  setPlatformAlbum!: Sequelize.BelongsToSetAssociationMixin<PlatformAlbum, PlatformAlbumId>;
+  createPlatformAlbum!: Sequelize.BelongsToCreateAssociationMixin<PlatformAlbum>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformAlbumRelation {
+    return CanonToPlatformAlbumRelation.init({
+    canonAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_album',
+        key: 'id'
+      },
+      field: 'canon_album_id'
+    },
+    platformAlbumId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_album',
+        key: 'id'
+      },
+      field: 'platform_album_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'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_to_platform_album_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_to_platform_album_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_album_id" },
+          { name: "platform_album_id" },
+        ]
+      },
+      {
+        name: "idx_c2p_album_platform",
+        fields: [
+          { name: "platform_album_id" },
+        ]
+      },
+    ]
+  });
+  }
+}

package/models/CanonToPlatformArtistRelation.ts

@@ -0,0 +1,92 @@
+import * as Sequelize from 'sequelize';
+import { DataTypes, Model, Optional } from 'sequelize';
+import type { CanonArtist, CanonArtistId } from './CanonArtist';
+import type { PlatformArtist, PlatformArtistId } from './PlatformArtist';
+
+export interface CanonToPlatformArtistRelationAttributes {
+  canonArtistId: string;
+  platformArtistId: string;
+  createDate: Date;
+  updateDate: Date;
+}
+
+export type CanonToPlatformArtistRelationPk = "canonArtistId" | "platformArtistId";
+export type CanonToPlatformArtistRelationId = CanonToPlatformArtistRelation[CanonToPlatformArtistRelationPk];
+export type CanonToPlatformArtistRelationOptionalAttributes = "createDate" | "updateDate";
+export type CanonToPlatformArtistRelationCreationAttributes = Optional<CanonToPlatformArtistRelationAttributes, CanonToPlatformArtistRelationOptionalAttributes>;
+
+export class CanonToPlatformArtistRelation extends Model<CanonToPlatformArtistRelationAttributes, CanonToPlatformArtistRelationCreationAttributes> implements CanonToPlatformArtistRelationAttributes {
+  canonArtistId!: string;
+  platformArtistId!: string;
+  createDate!: Date;
+  updateDate!: Date;
+
+  // CanonToPlatformArtistRelation belongsTo CanonArtist via canonArtistId
+  canonArtist!: CanonArtist;
+  getCanonArtist!: Sequelize.BelongsToGetAssociationMixin<CanonArtist>;
+  setCanonArtist!: Sequelize.BelongsToSetAssociationMixin<CanonArtist, CanonArtistId>;
+  createCanonArtist!: Sequelize.BelongsToCreateAssociationMixin<CanonArtist>;
+  // CanonToPlatformArtistRelation belongsTo PlatformArtist via platformArtistId
+  platformArtist!: PlatformArtist;
+  getPlatformArtist!: Sequelize.BelongsToGetAssociationMixin<PlatformArtist>;
+  setPlatformArtist!: Sequelize.BelongsToSetAssociationMixin<PlatformArtist, PlatformArtistId>;
+  createPlatformArtist!: Sequelize.BelongsToCreateAssociationMixin<PlatformArtist>;
+
+  static initModel(sequelize: Sequelize.Sequelize): typeof CanonToPlatformArtistRelation {
+    return CanonToPlatformArtistRelation.init({
+    canonArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'canon_artist',
+        key: 'id'
+      },
+      field: 'canon_artist_id'
+    },
+    platformArtistId: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      primaryKey: true,
+      references: {
+        model: 'platform_artist',
+        key: 'id'
+      },
+      field: 'platform_artist_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'
+    }
+  }, {
+    sequelize,
+    tableName: 'canon_to_platform_artist_relation',
+    schema: 'eb',
+    timestamps: false,
+    indexes: [
+      {
+        name: "canon_to_platform_artist_relation_pkey",
+        unique: true,
+        fields: [
+          { name: "canon_artist_id" },
+          { name: "platform_artist_id" },
+        ]
+      },
+      {
+        name: "idx_c2p_artist_platform",
+        fields: [
+          { name: "platform_artist_id" },
+        ]
+      },
+    ]
+  });
+  }
+}