@infuro/cms-core 1.0.34 → 1.0.36

package/dist/migrations/1779800000000-EventsAndEventProducts.ts

@@ -0,0 +1,173 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+const PERMISSION_ENTITIES = ['events', 'event_products'];
+
+export class EventsAndEventProducts1779800000000 implements MigrationInterface {
+  name = 'EventsAndEventProducts1779800000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "events" (
+        "id" SERIAL NOT NULL,
+        "vendorId" integer,
+        "name" character varying NOT NULL,
+        "slug" character varying NOT NULL,
+        "description" text,
+        "isActive" boolean NOT NULL DEFAULT true,
+        "comingSoon" boolean NOT NULL DEFAULT false,
+        "bannerImageUrl" character varying,
+        "logoUrl" character varying,
+        "venue" character varying,
+        "startDate" TIMESTAMP,
+        "endDate" TIMESTAMP,
+        "pricingType" character varying,
+        "entityTypes" jsonb,
+        "entityMode" character varying,
+        "cityCountry" character varying,
+        "defaultCurrency" character varying,
+        "supportedCurrencies" jsonb,
+        "officialWebsiteUrl" character varying,
+        "supportContact" character varying,
+        "allowGroupOrders" boolean NOT NULL DEFAULT false,
+        "sendIndividualTicketPDFToAttendees" boolean NOT NULL DEFAULT false,
+        "maxGroupPurchaseQuantity" integer,
+        "sponsors" jsonb,
+        "sortOrder" integer NOT NULL DEFAULT 0,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "deletedAt" TIMESTAMP,
+        "deleted" boolean NOT NULL DEFAULT false,
+        "createdBy" integer,
+        "updatedBy" integer,
+        "deletedBy" integer,
+        CONSTRAINT "PK_events" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'FK_events_vendor') THEN
+          ALTER TABLE "events"
+            ADD CONSTRAINT "FK_events_vendor"
+            FOREIGN KEY ("vendorId") REFERENCES "vendors"("id") ON DELETE RESTRICT ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_events_vendor_slug"
+        ON "events" ("vendorId", "slug")
+        WHERE "deleted" = false
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "event_products" (
+        "id" SERIAL NOT NULL,
+        "eventId" integer NOT NULL,
+        "productId" integer NOT NULL,
+        "displayOrder" integer NOT NULL DEFAULT 0,
+        "isActive" boolean NOT NULL DEFAULT true,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        CONSTRAINT "PK_event_products" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'FK_event_products_event') THEN
+          ALTER TABLE "event_products"
+            ADD CONSTRAINT "FK_event_products_event"
+            FOREIGN KEY ("eventId") REFERENCES "events"("id") ON DELETE CASCADE ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'FK_event_products_product') THEN
+          ALTER TABLE "event_products"
+            ADD CONSTRAINT "FK_event_products_product"
+            FOREIGN KEY ("productId") REFERENCES "products"("id") ON DELETE CASCADE ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_event_products_event_product"
+        ON "event_products" ("eventId", "productId")
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_event_products_event"
+        ON "event_products" ("eventId")
+    `);
+
+    for (const entity of PERMISSION_ENTITIES) {
+      await queryRunner.query(`
+        INSERT INTO "permissions" ("groupId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+        SELECT g.id, '${entity}', true, true, true, true
+        FROM "user_groups" g
+        WHERE g.name = 'Administrator' AND g.deleted = false
+        ON CONFLICT ("groupId", "entity") DO UPDATE SET
+          "canCreate" = EXCLUDED."canCreate",
+          "canRead" = EXCLUDED."canRead",
+          "canUpdate" = EXCLUDED."canUpdate",
+          "canDelete" = EXCLUDED."canDelete",
+          "updatedAt" = now()
+      `);
+
+      await queryRunner.query(`
+        INSERT INTO "permissions" ("groupId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+        SELECT g.id, '${entity}', true, true, true, true
+        FROM "user_groups" g
+        WHERE g.deleted = false
+          AND lower(g.name) LIKE '%vendor%'
+          AND g.name <> 'Administrator'
+        ON CONFLICT ("groupId", "entity") DO NOTHING
+      `);
+    }
+
+    for (const entity of PERMISSION_ENTITIES) {
+      await queryRunner.query(`
+        INSERT INTO "vendor_role_permissions"
+          ("vendorRoleId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+        SELECT vr.id, '${entity}', true, true, true, true
+        FROM "vendor_roles" vr
+        WHERE vr."isOwnerRole" = true AND vr.deleted = false
+        ON CONFLICT ("vendorRoleId", "entity") DO NOTHING
+      `);
+
+      await queryRunner.query(`
+        INSERT INTO "vendor_role_permissions"
+          ("vendorRoleId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+        SELECT vr.id, '${entity}', false, true, false, false
+        FROM "vendor_roles" vr
+        WHERE vr.name = 'Viewer' AND vr.deleted = false
+        ON CONFLICT ("vendorRoleId", "entity") DO NOTHING
+      `);
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const entities = PERMISSION_ENTITIES.map((e) => `'${e}'`).join(', ');
+    await queryRunner.query(`
+      DELETE FROM "permissions" p
+      WHERE p.entity IN (${entities})
+    `);
+
+    await queryRunner.query(`DROP INDEX IF EXISTS "IDX_event_products_event"`);
+    await queryRunner.query(`DROP INDEX IF EXISTS "UQ_event_products_event_product"`);
+    await queryRunner.query(
+      `ALTER TABLE "event_products" DROP CONSTRAINT IF EXISTS "FK_event_products_product"`
+    );
+    await queryRunner.query(
+      `ALTER TABLE "event_products" DROP CONSTRAINT IF EXISTS "FK_event_products_event"`
+    );
+    await queryRunner.query(`DROP TABLE IF EXISTS "event_products"`);
+
+    await queryRunner.query(`DROP INDEX IF EXISTS "UQ_events_vendor_slug"`);
+    await queryRunner.query(`ALTER TABLE "events" DROP CONSTRAINT IF EXISTS "FK_events_vendor"`);
+    await queryRunner.query(`DROP TABLE IF EXISTS "events"`);
+  }
+}

package/dist/migrations/1779810000000-BackfillVendorRoleEventsPermissions.ts

@@ -0,0 +1,38 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+const PERMISSION_ENTITIES = ['events', 'event_products'];
+
+/** Backfill vendor_role_permissions for events (owner roles seeded before events existed). */
+export class BackfillVendorRoleEventsPermissions1779810000000 implements MigrationInterface {
+  name = 'BackfillVendorRoleEventsPermissions1779810000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    for (const entity of PERMISSION_ENTITIES) {
+      await queryRunner.query(`
+        INSERT INTO "vendor_role_permissions"
+          ("vendorRoleId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+        SELECT vr.id, '${entity}', true, true, true, true
+        FROM "vendor_roles" vr
+        WHERE vr."isOwnerRole" = true AND vr.deleted = false
+        ON CONFLICT ("vendorRoleId", "entity") DO NOTHING
+      `);
+
+      await queryRunner.query(`
+        INSERT INTO "vendor_role_permissions"
+          ("vendorRoleId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+        SELECT vr.id, '${entity}', false, true, false, false
+        FROM "vendor_roles" vr
+        WHERE vr.name = 'Viewer' AND vr.deleted = false
+        ON CONFLICT ("vendorRoleId", "entity") DO NOTHING
+      `);
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const entities = PERMISSION_ENTITIES.map((e) => `'${e}'`).join(', ');
+    await queryRunner.query(`
+      DELETE FROM "vendor_role_permissions"
+      WHERE entity IN (${entities})
+    `);
+  }
+}

package/dist/migrations/1779820000000-FixProductsCategoryForeignKey.ts

@@ -0,0 +1,70 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Repair products.categoryId FK when it incorrectly references blog `categories`
+ * instead of `product_categories` (store catalog types).
+ */
+export class FixProductsCategoryForeignKey1779820000000 implements MigrationInterface {
+  name = 'FixProductsCategoryForeignKey1779820000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "products" DROP CONSTRAINT IF EXISTS "FK_products_category"
+    `);
+
+    await queryRunner.query(`
+      UPDATE "products" p
+      SET "categoryId" = pc."id"
+      FROM "categories" c
+      INNER JOIN "product_categories" pc
+        ON lower(pc."name") = lower(c."name")
+        AND pc."isCatalog" = true
+        AND pc."deleted" = false
+      WHERE p."categoryId" = c."id"
+        AND c."deleted" = false
+        AND NOT EXISTS (
+          SELECT 1 FROM "product_categories" x
+          WHERE x."id" = p."categoryId" AND x."deleted" = false
+        )
+    `);
+
+    await queryRunner.query(`
+      UPDATE "products" p
+      SET "categoryId" = NULL
+      WHERE p."categoryId" IS NOT NULL
+        AND NOT EXISTS (
+          SELECT 1 FROM "product_categories" pc
+          WHERE pc."id" = p."categoryId" AND pc."deleted" = false
+        )
+    `);
+
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_constraint
+          WHERE conname = 'FK_products_category'
+            AND conrelid = 'products'::regclass
+        ) THEN
+          ALTER TABLE "products"
+          ADD CONSTRAINT "FK_products_category"
+          FOREIGN KEY ("categoryId") REFERENCES "product_categories"("id")
+          ON DELETE SET NULL ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "products" DROP CONSTRAINT IF EXISTS "FK_products_category"
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "products"
+      ADD CONSTRAINT "FK_products_category"
+      FOREIGN KEY ("categoryId") REFERENCES "product_categories"("id")
+      ON DELETE SET NULL ON UPDATE NO ACTION
+    `);
+  }
+}

package/dist/migrations/1779830000000-ProductTitleColumn.ts

@@ -0,0 +1,32 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/** Align products.name and products.title so ticket/product labels persist reliably. */
+export class ProductTitleColumn1779830000000 implements MigrationInterface {
+  name = 'ProductTitleColumn1779830000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "products" ADD COLUMN IF NOT EXISTS "title" character varying
+    `);
+
+    await queryRunner.query(`
+      UPDATE "products"
+      SET "title" = "name"
+      WHERE ("title" IS NULL OR TRIM("title") = '')
+        AND "name" IS NOT NULL
+        AND TRIM("name") <> ''
+    `);
+
+    await queryRunner.query(`
+      UPDATE "products"
+      SET "name" = "title"
+      WHERE ("name" IS NULL OR TRIM("name") = '')
+        AND "title" IS NOT NULL
+        AND TRIM("title") <> ''
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "products" DROP COLUMN IF EXISTS "title"`);
+  }
+}

package/dist/migrations/1779840000000-EventAboutAndVisibilityFields.ts

@@ -0,0 +1,34 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EventAboutAndVisibilityFields1779840000000 implements MigrationInterface {
+  name = 'EventAboutAndVisibilityFields1779840000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "visibility" character varying NOT NULL DEFAULT 'public'
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "additionalVenueDetails" text
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "expectedSpeakers" integer
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "expectedParticipants" integer
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "expectedParticipants"`);
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "expectedSpeakers"`);
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "additionalVenueDetails"`);
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "visibility"`);
+  }
+}

package/dist/migrations/1779850000000-EventCityCountrySplit.ts

@@ -0,0 +1,43 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EventCityCountrySplit1779850000000 implements MigrationInterface {
+  name = 'EventCityCountrySplit1779850000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "city" character varying
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "country" character varying
+    `);
+
+    await queryRunner.query(`
+      UPDATE "events"
+      SET
+        "city" = NULLIF(trim(split_part("cityCountry", ',', 1)), ''),
+        "country" = NULLIF(trim(substring("cityCountry" from position(',' in "cityCountry") + 1)), '')
+      WHERE "cityCountry" IS NOT NULL
+        AND trim("cityCountry") <> ''
+        AND ("city" IS NULL OR trim("city") = '')
+        AND ("country" IS NULL OR trim("country") = '')
+        AND position(',' in "cityCountry") > 0
+    `);
+
+    await queryRunner.query(`
+      UPDATE "events"
+      SET "city" = NULLIF(trim("cityCountry"), '')
+      WHERE "cityCountry" IS NOT NULL
+        AND trim("cityCountry") <> ''
+        AND ("city" IS NULL OR trim("city") = '')
+        AND position(',' in "cityCountry") = 0
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "country"`);
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "city"`);
+  }
+}

package/dist/migrations/1779860000000-CreateCombos.ts

@@ -0,0 +1,140 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class CreateCombos1779860000000
+  implements MigrationInterface
+{
+  name = 'CreateCombos1779860000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE "combos_status_enum"
+        AS ENUM ('active', 'inactive', 'draft');
+      EXCEPTION
+        WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE "combo_items_type_enum"
+        AS ENUM ('fixed', 'addons');
+      EXCEPTION
+        WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "combos" (
+        "id" SERIAL NOT NULL,
+        "name" character varying NOT NULL,
+        "desc" text,
+        "eventId" integer NOT NULL,
+        "price" decimal(12,2) NOT NULL DEFAULT 0,
+        "minSelectableItems" integer NOT NULL DEFAULT 1,
+        "maxSelectableItems" integer NOT NULL DEFAULT 1,
+        "status" "combos_status_enum" NOT NULL DEFAULT 'active',
+        "startsAt" TIMESTAMP,
+        "endsAt" TIMESTAMP,
+        "metadata" jsonb,
+        "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+        "deletedAt" TIMESTAMP,
+        "deleted" boolean NOT NULL DEFAULT false,
+        "createdBy" integer,
+        "updatedBy" integer,
+        "deletedBy" integer,
+        CONSTRAINT "PK_combos" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'FK_combos_event'
+        ) THEN
+          ALTER TABLE "combos"
+          ADD CONSTRAINT "FK_combos_event"
+          FOREIGN KEY ("eventId")
+          REFERENCES "events"("id")
+          ON DELETE CASCADE
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "combo_items" (
+        "id" SERIAL NOT NULL,
+        "comboId" integer NOT NULL,
+        "productId" integer NOT NULL,
+        "type" "combo_items_type_enum" NOT NULL DEFAULT 'fixed',
+        CONSTRAINT "PK_combo_items" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'FK_combo_items_combo'
+        ) THEN
+          ALTER TABLE "combo_items"
+          ADD CONSTRAINT "FK_combo_items_combo"
+          FOREIGN KEY ("comboId")
+          REFERENCES "combos"("id")
+          ON DELETE CASCADE
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'FK_combo_items_product'
+        ) THEN
+          ALTER TABLE "combo_items"
+          ADD CONSTRAINT "FK_combo_items_product"
+          FOREIGN KEY ("productId")
+          REFERENCES "products"("id")
+          ON DELETE CASCADE
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_combo_items_combo"
+      ON "combo_items" ("comboId")
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_combo_items_product"
+      ON "combo_items" ("productId")
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DROP TABLE IF EXISTS "combo_items"
+    `);
+
+    await queryRunner.query(`
+      DROP TABLE IF EXISTS "combos"
+    `);
+
+    await queryRunner.query(`
+      DROP TYPE IF EXISTS "combo_items_type_enum"
+    `);
+
+    await queryRunner.query(`
+      DROP TYPE IF EXISTS "combos_status_enum"
+    `);
+  }
+}

package/dist/migrations/1780100000000-OrderAttendeesEventId.ts

@@ -0,0 +1,55 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Store CMS event id on each order_attendees pass (from event_products at sync time).
+ */
+export class OrderAttendeesEventId1780100000000 implements MigrationInterface {
+  name = 'OrderAttendeesEventId1780100000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const exists = await queryRunner.hasTable('order_attendees');
+    if (!exists) return;
+
+    const table = await queryRunner.getTable('order_attendees');
+    if (!table?.findColumnByName('eventId')) {
+      await queryRunner.query(`ALTER TABLE "order_attendees" ADD COLUMN "eventId" integer;`);
+      await queryRunner.query(
+        `CREATE INDEX IF NOT EXISTS "IDX_order_attendees_eventId" ON "order_attendees" ("eventId");`,
+      );
+    }
+
+    const hasEventProducts = await queryRunner.hasTable('event_products');
+    if (!hasEventProducts) return;
+
+    await queryRunner.query(`
+      UPDATE "order_attendees" oa
+      SET "eventId" = sub."eventId"
+      FROM (
+        SELECT DISTINCT ON (oa2.id)
+          oa2.id AS pass_id,
+          ep."eventId" AS "eventId"
+        FROM "order_attendees" oa2
+        INNER JOIN event_products ep
+          ON ep."productId" = (oa2."productId")::integer
+         AND ep."isActive" = true
+        WHERE oa2."eventId" IS NULL
+          AND oa2."productId" ~ '^[0-9]+$'
+        ORDER BY oa2.id, ep."eventId" ASC
+      ) sub
+      WHERE oa.id = sub.pass_id
+        AND oa."eventId" IS NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const exists = await queryRunner.hasTable('order_attendees');
+    if (!exists) return;
+
+    await queryRunner.query(`DROP INDEX IF EXISTS "IDX_order_attendees_eventId";`);
+
+    const table = await queryRunner.getTable('order_attendees');
+    if (table?.findColumnByName('eventId')) {
+      await queryRunner.query(`ALTER TABLE "order_attendees" DROP COLUMN "eventId";`);
+    }
+  }
+}

package/dist/migrations/1780110000000-EventContactFormId.ts

@@ -0,0 +1,49 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Link events to a CMS contact/attendee form for registration checkout.
+ */
+export class EventContactFormId1780110000000 implements MigrationInterface {
+  name = 'EventContactFormId1780110000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const hasEvents = await queryRunner.hasTable('events');
+    if (!hasEvents) return;
+
+    const table = await queryRunner.getTable('events');
+    if (!table?.findColumnByName('contactFormId')) {
+      await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "contactFormId" integer;`);
+    }
+
+    const hasForms = await queryRunner.hasTable('forms');
+    if (!hasForms) return;
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'FK_events_contactForm') THEN
+          ALTER TABLE "events"
+            ADD CONSTRAINT "FK_events_contactForm"
+            FOREIGN KEY ("contactFormId") REFERENCES "forms"("id")
+            ON DELETE SET NULL ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_events_contactFormId" ON "events" ("contactFormId");
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const hasEvents = await queryRunner.hasTable('events');
+    if (!hasEvents) return;
+
+    await queryRunner.query(`DROP INDEX IF EXISTS "IDX_events_contactFormId";`);
+    await queryRunner.query(`ALTER TABLE "events" DROP CONSTRAINT IF EXISTS "FK_events_contactForm";`);
+
+    const table = await queryRunner.getTable('events');
+    if (table?.findColumnByName('contactFormId')) {
+      await queryRunner.query(`ALTER TABLE "events" DROP COLUMN "contactFormId";`);
+    }
+  }
+}