@infuro/cms-core 1.0.33 → 1.0.35

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

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