@infuro/cms-core 1.0.33 → 1.0.35

package/dist/migrations/1779710000000-CollectionPlatformCatalog.ts

@@ -0,0 +1,60 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Platform catalog collections: global types (no vendor owner).
+ * Vendors assign products to these fixed collections.
+ */
+export class CollectionPlatformCatalog1779710000000 implements MigrationInterface {
+  name = 'CollectionPlatformCatalog1779710000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "collections"
+      ADD COLUMN IF NOT EXISTS "isCatalog" boolean NOT NULL DEFAULT false
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "collections"
+      ALTER COLUMN "vendorId" DROP NOT NULL
+    `);
+
+    await queryRunner.query(`
+      UPDATE "collections"
+      SET "isCatalog" = true
+      WHERE "deleted" = false
+    `);
+
+    await queryRunner.query(`
+      UPDATE "collections"
+      SET "vendorId" = NULL
+      WHERE "isCatalog" = true AND "deleted" = false
+    `);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_collections_catalog_slug"
+      ON "collections" ("slug")
+      WHERE "isCatalog" = true AND "deleted" = false
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS "UQ_collections_catalog_slug"`);
+
+    await queryRunner.query(`
+      UPDATE "collections" c
+      SET "vendorId" = COALESCE(
+        c."vendorId",
+        (SELECT id FROM "vendors" WHERE "slug" = 'default' AND "deleted" = false LIMIT 1),
+        (SELECT MIN(id) FROM "vendors" WHERE "deleted" = false)
+      )
+      WHERE c."isCatalog" = true AND c."vendorId" IS NULL
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "collections"
+      ALTER COLUMN "vendorId" SET NOT NULL
+    `);
+
+    await queryRunner.query(`ALTER TABLE "collections" DROP COLUMN IF EXISTS "isCatalog"`);
+  }
+}

package/dist/migrations/1779720000000-ProductCategoryPlatformCatalog.ts

@@ -0,0 +1,157 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Platform catalog categories: global types (no vendor owner).
+ * Vendors see these as tabs and create collections/products under them.
+ */
+export class ProductCategoryPlatformCatalog1779720000000 implements MigrationInterface {
+  name = 'ProductCategoryPlatformCatalog1779720000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "product_categories"
+      ADD COLUMN IF NOT EXISTS "isCatalog" boolean NOT NULL DEFAULT false
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "product_categories"
+      ALTER COLUMN "vendorId" DROP NOT NULL
+    `);
+
+    await queryRunner.query(`
+      INSERT INTO "product_categories" (
+        "vendorId", "name", "slug", "parentId", "image", "description", "metadata",
+        "active", "sortOrder", "isCatalog", "deleted", "createdAt", "updatedAt"
+      )
+      SELECT
+        NULL,
+        c."name",
+        c."slug",
+        NULL,
+        c."image",
+        c."description",
+        c."metadata",
+        c."active",
+        c."sortOrder",
+        true,
+        false,
+        NOW(),
+        NOW()
+      FROM "collections" c
+      WHERE c."isCatalog" = true
+        AND c."deleted" = false
+        AND NOT EXISTS (
+          SELECT 1 FROM "product_categories" pc
+          WHERE pc."isCatalog" = true
+            AND pc."deleted" = false
+            AND pc."slug" = c."slug"
+        )
+    `);
+
+    await queryRunner.query(`
+      UPDATE "products" p
+      SET "categoryId" = pc."id"
+      FROM "collections" c
+      JOIN "product_categories" pc
+        ON pc."isCatalog" = true
+        AND pc."deleted" = false
+        AND pc."slug" = c."slug"
+      WHERE p."collectionId" = c."id"
+        AND c."isCatalog" = true
+        AND c."deleted" = false
+        AND (p."categoryId" IS NULL OR p."categoryId" != pc."id")
+    `);
+
+    await queryRunner.query(`
+      INSERT INTO "collections" (
+        "vendorId", "categoryId", "brandId", "name", "slug", "hsn", "description", "image",
+        "metadata", "variants", "active", "isCatalog", "sortOrder", "deleted", "createdAt", "updatedAt"
+      )
+      SELECT DISTINCT ON (p."vendorId", c."slug")
+        p."vendorId",
+        pc."id",
+        c."brandId",
+        c."name",
+        c."slug" || '-v' || p."vendorId",
+        c."hsn",
+        c."description",
+        c."image",
+        c."metadata",
+        c."variants",
+        c."active",
+        false,
+        c."sortOrder",
+        false,
+        NOW(),
+        NOW()
+      FROM "products" p
+      JOIN "collections" c ON c."id" = p."collectionId" AND c."isCatalog" = true AND c."deleted" = false
+      JOIN "product_categories" pc ON pc."isCatalog" = true AND pc."deleted" = false AND pc."slug" = c."slug"
+      WHERE NOT EXISTS (
+        SELECT 1 FROM "collections" vc
+        WHERE vc."vendorId" = p."vendorId"
+          AND vc."categoryId" = pc."id"
+          AND vc."isCatalog" = false
+          AND vc."deleted" = false
+          AND vc."slug" = c."slug" || '-v' || p."vendorId"
+      )
+    `);
+
+    await queryRunner.query(`
+      UPDATE "products" p
+      SET "collectionId" = vc."id"
+      FROM "collections" c
+      JOIN "product_categories" pc
+        ON pc."isCatalog" = true
+        AND pc."deleted" = false
+        AND pc."slug" = c."slug"
+      JOIN "collections" vc
+        ON vc."categoryId" = pc."id"
+        AND vc."isCatalog" = false
+        AND vc."deleted" = false
+      WHERE p."collectionId" = c."id"
+        AND c."isCatalog" = true
+        AND c."deleted" = false
+        AND p."vendorId" = vc."vendorId"
+        AND vc."slug" = c."slug" || '-v' || p."vendorId"
+    `);
+
+    await queryRunner.query(`
+      UPDATE "collections"
+      SET "isCatalog" = false,
+          "vendorId" = COALESCE(
+            "vendorId",
+            (SELECT id FROM "vendors" WHERE "slug" = 'default' AND "deleted" = false LIMIT 1),
+            (SELECT MIN(id) FROM "vendors" WHERE "deleted" = false)
+          )
+      WHERE "isCatalog" = true AND "deleted" = false
+    `);
+
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "UQ_product_categories_catalog_slug"
+      ON "product_categories" ("slug")
+      WHERE "isCatalog" = true AND "deleted" = false
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS "UQ_product_categories_catalog_slug"`);
+
+    await queryRunner.query(`
+      UPDATE "product_categories" pc
+      SET "vendorId" = COALESCE(
+        pc."vendorId",
+        (SELECT id FROM "vendors" WHERE "slug" = 'default' AND "deleted" = false LIMIT 1),
+        (SELECT MIN(id) FROM "vendors" WHERE "deleted" = false)
+      )
+      WHERE pc."isCatalog" = true AND pc."vendorId" IS NULL
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "product_categories"
+      ALTER COLUMN "vendorId" SET NOT NULL
+    `);
+
+    await queryRunner.query(`ALTER TABLE "product_categories" DROP COLUMN IF EXISTS "isCatalog"`);
+  }
+}

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"`);
+  }
+}