@infuro/cms-core 1.0.34 → 1.0.36

package/dist/migrations/1780130000000-ProductVariants.ts

@@ -0,0 +1,54 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ProductVariants1780130000000 implements MigrationInterface {
+  name = 'ProductVariants1780130000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const hasProducts = await queryRunner.hasTable('products');
+    if (!hasProducts) return;
+
+    const exists = await queryRunner.hasTable('product_variants');
+    if (!exists) {
+      await queryRunner.query(`
+        CREATE TABLE "product_variants" (
+          "id" SERIAL NOT NULL,
+          "productId" integer NOT NULL,
+          "sku" character varying,
+          "price" numeric(12,2),
+          "compareAtPrice" numeric(12,2),
+          "inventory" integer NOT NULL DEFAULT 0,
+          "status" character varying NOT NULL DEFAULT 'draft',
+          "attributes" jsonb,
+          "imageUrls" jsonb,
+          "createdAt" TIMESTAMP NOT NULL DEFAULT now(),
+          "updatedAt" TIMESTAMP NOT NULL DEFAULT now(),
+          CONSTRAINT "PK_product_variants" PRIMARY KEY ("id")
+        )
+      `);
+    }
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'FK_product_variants_product') THEN
+          ALTER TABLE "product_variants"
+            ADD CONSTRAINT "FK_product_variants_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_product_variants_productId" ON "product_variants" ("productId");
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    const exists = await queryRunner.hasTable('product_variants');
+    if (!exists) return;
+
+    await queryRunner.query(`DROP INDEX IF EXISTS "IDX_product_variants_productId";`);
+    await queryRunner.query(`ALTER TABLE "product_variants" DROP CONSTRAINT IF EXISTS "FK_product_variants_product";`);
+    await queryRunner.query(`DROP TABLE "product_variants";`);
+  }
+}

package/dist/migrations/1780140000000-EventManagementEnhancements.ts

@@ -0,0 +1,44 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EventManagementEnhancements1780140000000 implements MigrationInterface {
+  name = 'EventManagementEnhancements1780140000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasTable('events')) {
+      const events = await queryRunner.getTable('events');
+      if (!events?.findColumnByName('socialMediaLinks')) {
+        await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "socialMediaLinks" jsonb;`);
+      }
+      if (!events?.findColumnByName('timezone')) {
+        await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "timezone" character varying;`);
+      }
+    }
+
+    if (await queryRunner.hasTable('products')) {
+      const products = await queryRunner.getTable('products');
+      if (!products?.findColumnByName('currencyPrices')) {
+        await queryRunner.query(`ALTER TABLE "products" ADD COLUMN "currencyPrices" jsonb;`);
+      }
+    }
+
+    if (await queryRunner.hasTable('product_variants')) {
+      const variants = await queryRunner.getTable('product_variants');
+      if (!variants?.findColumnByName('currencyPrices')) {
+        await queryRunner.query(`ALTER TABLE "product_variants" ADD COLUMN "currencyPrices" jsonb;`);
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasTable('events')) {
+      await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "socialMediaLinks";`);
+      await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "timezone";`);
+    }
+    if (await queryRunner.hasTable('products')) {
+      await queryRunner.query(`ALTER TABLE "products" DROP COLUMN IF EXISTS "currencyPrices";`);
+    }
+    if (await queryRunner.hasTable('product_variants')) {
+      await queryRunner.query(`ALTER TABLE "product_variants" DROP COLUMN IF EXISTS "currencyPrices";`);
+    }
+  }
+}

package/dist/migrations/1780160000000-EventRegistrationGstProductContactForm.ts

@@ -0,0 +1,79 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EventRegistrationGstProductContactForm1780160000000 implements MigrationInterface {
+  name = 'EventRegistrationGstProductContactForm1780160000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasTable('events')) {
+      const events = await queryRunner.getTable('events');
+      if (!events?.findColumnByName('registrationOpensAt')) {
+        await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "registrationOpensAt" TIMESTAMP;`);
+      }
+      if (!events?.findColumnByName('registrationClosesAt')) {
+        await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "registrationClosesAt" TIMESTAMP;`);
+      }
+      if (!events?.findColumnByName('taxId')) {
+        await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "taxId" integer;`);
+      }
+      if (!events?.findColumnByName('taxRate')) {
+        await queryRunner.query(
+          `ALTER TABLE "events" ADD COLUMN "taxRate" numeric(5,2);`
+        );
+      }
+    }
+
+    if (await queryRunner.hasTable('taxes') && (await queryRunner.hasTable('events'))) {
+      await queryRunner.query(`
+        DO $$ BEGIN
+          IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'FK_events_tax') THEN
+            ALTER TABLE "events"
+              ADD CONSTRAINT "FK_events_tax"
+              FOREIGN KEY ("taxId") REFERENCES "taxes"("id")
+              ON DELETE SET NULL ON UPDATE NO ACTION;
+          END IF;
+        END $$;
+      `);
+      await queryRunner.query(`CREATE INDEX IF NOT EXISTS "IDX_events_taxId" ON "events" ("taxId");`);
+    }
+
+    if (await queryRunner.hasTable('products')) {
+      const products = await queryRunner.getTable('products');
+      if (!products?.findColumnByName('contactFormId')) {
+        await queryRunner.query(`ALTER TABLE "products" ADD COLUMN "contactFormId" integer;`);
+      }
+    }
+
+    if (await queryRunner.hasTable('forms') && (await queryRunner.hasTable('products'))) {
+      await queryRunner.query(`
+        DO $$ BEGIN
+          IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'FK_products_contactForm') THEN
+            ALTER TABLE "products"
+              ADD CONSTRAINT "FK_products_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_products_contactFormId" ON "products" ("contactFormId");`
+      );
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasTable('products')) {
+      await queryRunner.query(`DROP INDEX IF EXISTS "IDX_products_contactFormId";`);
+      await queryRunner.query(`ALTER TABLE "products" DROP CONSTRAINT IF EXISTS "FK_products_contactForm";`);
+      await queryRunner.query(`ALTER TABLE "products" DROP COLUMN IF EXISTS "contactFormId";`);
+    }
+
+    if (await queryRunner.hasTable('events')) {
+      await queryRunner.query(`DROP INDEX IF EXISTS "IDX_events_taxId";`);
+      await queryRunner.query(`ALTER TABLE "events" DROP CONSTRAINT IF EXISTS "FK_events_tax";`);
+      await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "taxRate";`);
+      await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "taxId";`);
+      await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "registrationClosesAt";`);
+      await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "registrationOpensAt";`);
+    }
+  }
+}

package/dist/migrations/1780170000000-ComboCurrencyPrices.ts

@@ -0,0 +1,20 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ComboCurrencyPrices1780170000000 implements MigrationInterface {
+  name = 'ComboCurrencyPrices1780170000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasTable('combos')) {
+      const table = await queryRunner.getTable('combos');
+      if (!table?.findColumnByName('currencyPrices')) {
+        await queryRunner.query(`ALTER TABLE "combos" ADD COLUMN "currencyPrices" jsonb;`);
+      }
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    if (await queryRunner.hasTable('combos')) {
+      await queryRunner.query(`ALTER TABLE "combos" DROP COLUMN IF EXISTS "currencyPrices";`);
+    }
+  }
+}

package/dist/migrations/1781110000000-VendorOwnerCombosPermission.ts

@@ -0,0 +1,38 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class VendorOwnerCombosPermission1781110000000
+  implements MigrationInterface
+{
+  name = 'VendorOwnerCombosPermission1781110000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      INSERT INTO "permissions"
+        ("groupId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+      SELECT
+        g.id,
+        'combos',
+        true,
+        true,
+        true,
+        false
+      FROM "user_groups" g
+      WHERE g.name = 'Vendor Owner'
+        AND g.deleted = false
+      ON CONFLICT ("groupId", "entity") DO UPDATE SET
+        "canCreate" = true,
+        "canRead" = true,
+        "canUpdate" = true
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM "permissions" p
+      USING "user_groups" g
+      WHERE p."groupId" = g.id
+        AND g.name = 'Vendor Owner'
+        AND p.entity = 'combos'
+    `);
+  }
+}

package/dist/migrations/1781120000000-RefundPoliciesAndRequests.ts

@@ -0,0 +1,225 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class RefundPoliciesAndRequests1781120000000
+  implements MigrationInterface
+{
+  name = 'RefundPoliciesAndRequests1781120000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // =========================
+    // ENUMS
+    // =========================
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE "refund_policies_status_enum"
+        AS ENUM ('active', 'inactive');
+      EXCEPTION
+        WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE "refund_policies_type_enum"
+        AS ENUM ('percentage');
+      EXCEPTION
+        WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE "refund_requests_method_enum"
+        AS ENUM ('card', 'upi', 'net_banking');
+      EXCEPTION
+        WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        CREATE TYPE "refund_requests_status_enum"
+        AS ENUM ('requested', 'approved', 'rejected', 'refunded');
+      EXCEPTION
+        WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    // =========================
+    // REFUND POLICIES
+    // =========================
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "refund_policies" (
+        "id" SERIAL NOT NULL,
+        "name" character varying NOT NULL,
+        "desc" text,
+        "vendorId" integer NOT NULL,
+        "refundWindowDays" integer NOT NULL DEFAULT 0,
+        "status" "refund_policies_status_enum" NOT NULL DEFAULT 'active',
+        "type" "refund_policies_type_enum" NOT NULL DEFAULT 'percentage',
+        "value" decimal(10,2) NOT NULL DEFAULT 0,
+        CONSTRAINT "PK_refund_policies" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'FK_refund_policies_vendor'
+        ) THEN
+          ALTER TABLE "refund_policies"
+          ADD CONSTRAINT "FK_refund_policies_vendor"
+          FOREIGN KEY ("vendorId")
+          REFERENCES "vendors"("id")
+          ON DELETE CASCADE
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    // =========================
+    // REFUND REQUESTS
+    // =========================
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "refund_requests" (
+        "id" SERIAL NOT NULL,
+        "refundPolicyId" integer NOT NULL,
+        "orderId" integer NOT NULL,
+        "customerId" integer NOT NULL,
+        "reason" text,
+        "refundMethod" "refund_requests_method_enum" NOT NULL,
+        "status" "refund_requests_status_enum" NOT NULL DEFAULT 'requested',
+        "expectedRefundAmount" decimal(10,2) NOT NULL DEFAULT 0,
+        "approvedRefundAmount" decimal(10,2),
+        CONSTRAINT "PK_refund_requests" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'FK_refund_requests_policy'
+        ) THEN
+          ALTER TABLE "refund_requests"
+          ADD CONSTRAINT "FK_refund_requests_policy"
+          FOREIGN KEY ("refundPolicyId")
+          REFERENCES "refund_policies"("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_refund_requests_order'
+        ) THEN
+          ALTER TABLE "refund_requests"
+          ADD CONSTRAINT "FK_refund_requests_order"
+          FOREIGN KEY ("orderId")
+          REFERENCES "orders"("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_refund_requests_customer'
+        ) THEN
+          ALTER TABLE "refund_requests"
+          ADD CONSTRAINT "FK_refund_requests_customer"
+          FOREIGN KEY ("customerId")
+          REFERENCES "customer"("id")
+          ON DELETE CASCADE
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    // =========================
+    // ORDER ITEMS -> vendorId
+    // =========================
+
+    await queryRunner.query(`
+      ALTER TABLE "order_items"
+      ADD COLUMN IF NOT EXISTS "vendorId" integer
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'FK_order_items_vendor'
+        ) THEN
+          ALTER TABLE "order_items"
+          ADD CONSTRAINT "FK_order_items_vendor"
+          FOREIGN KEY ("vendorId")
+          REFERENCES "vendors"("id")
+          ON DELETE SET NULL
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_order_items_vendor"
+      ON "order_items" ("vendorId")
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DROP INDEX IF EXISTS "IDX_order_items_vendor"
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "order_items"
+      DROP CONSTRAINT IF EXISTS "FK_order_items_vendor"
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "order_items"
+      DROP COLUMN IF EXISTS "vendorId"
+    `);
+
+    await queryRunner.query(`
+      DROP TABLE IF EXISTS "refund_requests"
+    `);
+
+    await queryRunner.query(`
+      DROP TABLE IF EXISTS "refund_policies"
+    `);
+
+    await queryRunner.query(`
+      DROP TYPE IF EXISTS "refund_requests_status_enum"
+    `);
+
+    await queryRunner.query(`
+      DROP TYPE IF EXISTS "refund_requests_method_enum"
+    `);
+
+    await queryRunner.query(`
+      DROP TYPE IF EXISTS "refund_policies_type_enum"
+    `);
+
+    await queryRunner.query(`
+      DROP TYPE IF EXISTS "refund_policies_status_enum"
+    `);
+  }
+}

package/dist/migrations/1781130000000-CreateAttendees.ts

@@ -0,0 +1,44 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Event / registration attendees linked optionally to CMS contacts.
+ */
+export class CreateAttendees1781130000000 implements MigrationInterface {
+  name = 'CreateAttendees1781130000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS "attendees" (
+        "id" SERIAL NOT NULL,
+        "displayName" character varying NOT NULL,
+        "email" character varying NOT NULL,
+        "contactId" integer,
+        CONSTRAINT "PK_attendees" PRIMARY KEY ("id")
+      )
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE "attendees"
+          ADD CONSTRAINT "FK_attendees_contact"
+          FOREIGN KEY ("contactId") REFERENCES "contacts"("id") ON DELETE SET NULL ON UPDATE NO ACTION;
+      EXCEPTION WHEN duplicate_object THEN NULL; END $$
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_attendees_contactId"
+      ON "attendees" ("contactId")
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_attendees_email"
+      ON "attendees" ("email")
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS "IDX_attendees_email"`);
+    await queryRunner.query(`DROP INDEX IF EXISTS "IDX_attendees_contactId"`);
+    await queryRunner.query(`DROP TABLE IF EXISTS "attendees"`);
+  }
+}

package/dist/migrations/1781140000000-EventOrderNotifications.ts

@@ -0,0 +1,29 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EventOrderNotifications1781140000000 implements MigrationInterface {
+  name = 'EventOrderNotifications1781140000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    if (!(await queryRunner.hasTable('events'))) return;
+
+    const table = await queryRunner.getTable('events');
+    if (!table?.findColumnByName('orderNotificationsEnabled')) {
+      await queryRunner.query(
+        `ALTER TABLE "events" ADD COLUMN "orderNotificationsEnabled" boolean NOT NULL DEFAULT false`,
+      );
+    }
+    if (!table?.findColumnByName('orderNotificationChannels')) {
+      await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "orderNotificationChannels" jsonb;`);
+    }
+    if (!table?.findColumnByName('orderNotificationTemplates')) {
+      await queryRunner.query(`ALTER TABLE "events" ADD COLUMN "orderNotificationTemplates" jsonb;`);
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    if (!(await queryRunner.hasTable('events'))) return;
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "orderNotificationTemplates"`);
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "orderNotificationChannels"`);
+    await queryRunner.query(`ALTER TABLE "events" DROP COLUMN IF EXISTS "orderNotificationsEnabled"`);
+  }
+}

package/dist/migrations/1781150000000-EventNamedLists.ts

@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/** Agenda, workshops, exhibitors, partners, and speaker rows on events (name + image URL). */
+export class EventNamedLists1781150000000 implements MigrationInterface {
+  name = 'EventNamedLists1781150000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "agenda" jsonb,
+      ADD COLUMN IF NOT EXISTS "workshops" jsonb,
+      ADD COLUMN IF NOT EXISTS "exhibitors" jsonb,
+      ADD COLUMN IF NOT EXISTS "partners" jsonb,
+      ADD COLUMN IF NOT EXISTS "speakers" jsonb
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      DROP COLUMN IF EXISTS "speakers",
+      DROP COLUMN IF EXISTS "partners",
+      DROP COLUMN IF EXISTS "exhibitors",
+      DROP COLUMN IF EXISTS "workshops",
+      DROP COLUMN IF EXISTS "agenda"
+    `);
+  }
+}

package/dist/migrations/1781160000000-RefundPolicyEventTiers.ts

@@ -0,0 +1,27 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class RefundPolicyEventTiers1781160000000 implements MigrationInterface {
+  name = 'RefundPolicyEventTiers1781160000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TYPE "refund_policies_type_enum" ADD VALUE IF NOT EXISTS 'event_tiers';
+      EXCEPTION
+        WHEN duplicate_object THEN NULL;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "refund_policies"
+      ADD COLUMN IF NOT EXISTS "tiers" jsonb
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "refund_policies"
+      DROP COLUMN IF EXISTS "tiers"
+    `);
+  }
+}

package/dist/migrations/1781170000000-EventRefundPolicy.ts

@@ -0,0 +1,42 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class EventRefundPolicy1781170000000 implements MigrationInterface {
+  name = 'EventRefundPolicy1781170000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "events"
+      ADD COLUMN IF NOT EXISTS "refundPolicyId" integer
+    `);
+
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1 FROM pg_constraint WHERE conname = 'FK_events_refund_policy'
+        ) THEN
+          ALTER TABLE "events"
+          ADD CONSTRAINT "FK_events_refund_policy"
+          FOREIGN KEY ("refundPolicyId")
+          REFERENCES "refund_policies"("id")
+          ON DELETE SET NULL
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_events_refundPolicyId"
+      ON "events" ("refundPolicyId")
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS "IDX_events_refundPolicyId"`);
+    await queryRunner.query(`
+      ALTER TABLE "events" DROP CONSTRAINT IF EXISTS "FK_events_refund_policy"
+    `);
+    await queryRunner.query(`
+      ALTER TABLE "events" DROP COLUMN IF EXISTS "refundPolicyId"
+    `);
+  }
+}

package/dist/migrations/1781180000000-RemoveCartItemsUniqueConstraint.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class RemoveCartItemsUniqueConstraint1781180000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "cart_items" DROP CONSTRAINT IF EXISTS "UQ_cart_items_cart_product"`
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "cart_items" ADD CONSTRAINT "UQ_cart_items_cart_product" UNIQUE ("cartId", "productId")`
+    );
+  }
+}