@infuro/cms-core 1.0.34 → 1.0.36

package/dist/migrations/1781190000000-RenameProductTaxesToProductConfig.ts

@@ -0,0 +1,84 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class RenameProductTaxesToProductConfig1781190000000
+  implements MigrationInterface
+{
+  name = 'RenameProductTaxesToProductConfig1781190000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    // Rename table if old table exists
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF EXISTS (
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_name = 'product_taxes'
+        ) THEN
+          ALTER TABLE "product_taxes"
+          RENAME TO "product_config";
+        END IF;
+      END $$;
+    `);
+
+    // Add refundPolicyId
+    await queryRunner.query(`
+      ALTER TABLE "product_config"
+      ADD COLUMN IF NOT EXISTS "refundPolicyId" integer
+    `);
+
+    // FK to refund policies
+    await queryRunner.query(`
+      DO $$ BEGIN
+        IF NOT EXISTS (
+          SELECT 1
+          FROM pg_constraint
+          WHERE conname = 'FK_product_config_refund_policy'
+        ) THEN
+          ALTER TABLE "product_config"
+          ADD CONSTRAINT "FK_product_config_refund_policy"
+          FOREIGN KEY ("refundPolicyId")
+          REFERENCES "refund_policies"("id")
+          ON DELETE SET NULL
+          ON UPDATE NO ACTION;
+        END IF;
+      END $$;
+    `);
+
+    // Index
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_product_config_refund_policy"
+      ON "product_config" ("refundPolicyId")
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DROP INDEX IF EXISTS "IDX_product_config_refund_policy"
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "product_config"
+      DROP CONSTRAINT IF EXISTS "FK_product_config_refund_policy"
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "product_config"
+      DROP COLUMN IF EXISTS "refundPolicyId"
+    `);
+
+    await queryRunner.query(`
+      DO $$
+      BEGIN
+        IF EXISTS (
+          SELECT 1
+          FROM information_schema.tables
+          WHERE table_name = 'product_config'
+        ) THEN
+          ALTER TABLE "product_config"
+          RENAME TO "product_taxes";
+        END IF;
+      END $$;
+    `);
+  }
+}

package/dist/migrations/1781200000000-VendorOwnerProductConfigPermissions.ts

@@ -0,0 +1,51 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class VendorOwnerProductConfigPermissions1781200000000
+  implements MigrationInterface
+{
+  name = 'VendorOwnerProductConfigPermissions1781200000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const entities = [
+      'product_variants',
+      'product_config',
+      'product_attributes',
+    ];
+
+    for (const entity of 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 = 'Vendor Owner'
+          AND g.deleted = false
+        ON CONFLICT ("groupId", "entity") DO UPDATE SET
+          "canCreate" = true,
+          "canRead" = true,
+          "canUpdate" = true,
+          "canDelete" = 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 IN (
+          'product_variants',
+          'product_config',
+          'product_attributes'
+        )
+    `);
+  }
+}

package/dist/migrations/1781210000000-VendorRoleProductConfigPermissions.ts

@@ -0,0 +1,46 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class VendorRoleProductConfigPermissions1781210000000
+  implements MigrationInterface
+{
+  name = 'VendorRoleProductConfigPermissions1781210000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const entities = [
+      'product_variants',
+      'product_config',
+      'product_attributes',
+    ];
+
+    for (const entity of 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
+        ON CONFLICT ("vendorRoleId", "entity") DO UPDATE SET
+          "canCreate" = true,
+          "canRead" = true,
+          "canUpdate" = true,
+          "canDelete" = true
+      `);
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM "vendor_role_permissions"
+      WHERE "entity" IN (
+        'product_variants',
+        'product_config',
+        'product_attributes'
+      )
+    `);
+  }
+}

package/dist/migrations/1781220000000-AddWhatsappTriggerBindings.ts

@@ -0,0 +1,23 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddWhatsappTriggerBindings1781220000000 implements MigrationInterface {
+  name = 'AddWhatsappTriggerBindings1781220000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE "whatsapp_trigger_bindings" (
+        "id" SERIAL PRIMARY KEY,
+        "triggerKey" varchar NOT NULL UNIQUE,
+        "messageTemplateId" int NOT NULL,
+        "enabled" boolean NOT NULL DEFAULT true,
+        "createdAt" timestamp NOT NULL DEFAULT now(),
+        "updatedAt" timestamp NOT NULL DEFAULT now(),
+        CONSTRAINT "FK_whatsapp_trigger_bindings_template" FOREIGN KEY ("messageTemplateId") REFERENCES "message_templates"("id") ON DELETE CASCADE
+      );
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE "whatsapp_trigger_bindings";`);
+  }
+}

package/dist/migrations/1781230000000-AddOrderNotificationTriggers.ts

@@ -0,0 +1,46 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddOrderNotificationTriggers1781230000000 implements MigrationInterface {
+  name = 'AddOrderNotificationTriggers1781230000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE "order_notification_triggers" (
+        "id" SERIAL PRIMARY KEY,
+        "triggerKey" varchar NOT NULL UNIQUE,
+        "label" varchar NOT NULL,
+        "description" text,
+        "category" varchar NOT NULL DEFAULT 'order',
+        "enabled" boolean NOT NULL DEFAULT true,
+        "sortOrder" int NOT NULL DEFAULT 0,
+        "createdAt" timestamp NOT NULL DEFAULT now(),
+        "updatedAt" timestamp NOT NULL DEFAULT now()
+      );
+    `);
+
+    await queryRunner.query(`
+      INSERT INTO "order_notification_triggers" ("triggerKey", "label", "description", "category", "sortOrder")
+      VALUES
+        ('order_placed', 'Order placed', 'Fires when a new order is created (storefront checkout or admin).', 'order', 1),
+        ('order_cancelled', 'Order cancelled', 'Fires when an order is cancelled.', 'order', 2),
+        ('order_refunded', 'Order refunded', 'Fires when a refund amount is processed on cancellation.', 'order', 3)
+      ON CONFLICT ("triggerKey") DO NOTHING;
+    `);
+
+    await queryRunner.query(`
+      ALTER TABLE "whatsapp_trigger_bindings"
+      ALTER COLUMN "messageTemplateId" DROP NOT NULL;
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM "whatsapp_trigger_bindings" WHERE "messageTemplateId" IS NULL;
+    `);
+    await queryRunner.query(`
+      ALTER TABLE "whatsapp_trigger_bindings"
+      ALTER COLUMN "messageTemplateId" SET NOT NULL;
+    `);
+    await queryRunner.query(`DROP TABLE "order_notification_triggers";`);
+  }
+}

package/dist/migrations/1781240000000-DropEventOrderNotificationColumns.ts

@@ -0,0 +1,29 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class DropEventOrderNotificationColumns1781240000000 implements MigrationInterface {
+  name = 'DropEventOrderNotificationColumns1781240000000';
+
+  public async up(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"`);
+  }
+
+  public async down(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;`);
+    }
+  }
+}

package/dist/migrations/1781250000000-RemoveOrderRefundedTrigger.ts

@@ -0,0 +1,36 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+/** Keep only order_placed and order_cancelled notification triggers. */
+export class RemoveOrderRefundedTrigger1781250000000 implements MigrationInterface {
+  name = 'RemoveOrderRefundedTrigger1781250000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      DELETE FROM "whatsapp_trigger_bindings" WHERE "triggerKey" = 'order_refunded';
+    `);
+    await queryRunner.query(`
+      DELETE FROM "order_notification_triggers" WHERE "triggerKey" = 'order_refunded';
+    `);
+    await queryRunner.query(`
+      UPDATE "order_notification_triggers"
+      SET
+        "description" = 'Fires when an order is cancelled (includes refund amount when applicable).',
+        "updatedAt" = now()
+      WHERE "triggerKey" = 'order_cancelled';
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      INSERT INTO "order_notification_triggers" ("triggerKey", "label", "description", "category", "sortOrder")
+      VALUES
+        ('order_refunded', 'Order refunded', 'Fires when a refund amount is processed on cancellation.', 'order', 3)
+      ON CONFLICT ("triggerKey") DO NOTHING;
+    `);
+    await queryRunner.query(`
+      UPDATE "order_notification_triggers"
+      SET "description" = 'Fires when an order is cancelled.', "updatedAt" = now()
+      WHERE "triggerKey" = 'order_cancelled';
+    `);
+  }
+}

package/dist/migrations/helpers/vendor-role-seed.ts

@@ -0,0 +1,243 @@
+import type { QueryRunner } from 'typeorm';
+
+/** Self-contained for dist/migrations — do not import from src/lib. */
+
+const RBAC_ENTITIES = [
+  'products',
+  'collections',
+  'brands',
+  'product_categories',
+  'orders',
+  'payments',
+  'taxes',
+  'attributes',
+  'vendor_customers',
+  'discounts',
+  'order_discounts',
+  'order_addresses',
+  'events',
+  'event_products',
+  'dashboard',
+  'settings',
+  'team',
+  'roles',
+] as const;
+
+type Perm = { c: boolean; r: boolean; u: boolean; d: boolean };
+
+type RoleDef = {
+  name: string;
+  description: string;
+  isSystem: boolean;
+  isOwnerRole: boolean;
+  permissions: Record<string, Perm>;
+};
+
+function full(): Perm {
+  return { c: true, r: true, u: true, d: true };
+}
+function read(): Perm {
+  return { c: false, r: true, u: false, d: false };
+}
+function none(): Perm {
+  return { c: false, r: false, u: false, d: false };
+}
+function readUpdate(): Perm {
+  return { c: false, r: true, u: true, d: false };
+}
+
+const STORE_ENTITIES = RBAC_ENTITIES.filter(
+  (e) => !['dashboard', 'settings', 'team', 'roles'].includes(e)
+);
+
+function storePerms(spec: Record<string, Perm | 'full' | 'read' | 'none'>): Record<string, Perm> {
+  const resolve = (v: Perm | 'full' | 'read' | 'none'): Perm => {
+    if (v === 'full') return full();
+    if (v === 'read') return read();
+    if (v === 'none') return none();
+    return v;
+  };
+  const out: Record<string, Perm> = {};
+  for (const entity of STORE_ENTITIES) {
+    out[entity] = resolve(spec[entity] ?? 'none');
+  }
+  return out;
+}
+
+const DEFAULT_ROLES: RoleDef[] = [
+  {
+    name: 'Owner',
+    description: 'Full store access and team/role management',
+    isSystem: true,
+    isOwnerRole: true,
+    permissions: {
+      ...storePerms(Object.fromEntries(STORE_ENTITIES.map((e) => [e, 'full']))),
+      dashboard: read(),
+      settings: readUpdate(),
+      team: full(),
+      roles: full(),
+    },
+  },
+  {
+    name: 'Manager',
+    description: 'Day-to-day store operations',
+    isSystem: true,
+    isOwnerRole: false,
+    permissions: {
+      ...storePerms({
+        products: 'full',
+        collections: 'full',
+        brands: 'full',
+        product_categories: 'full',
+        orders: 'full',
+        vendor_customers: 'full',
+        discounts: 'full',
+        order_discounts: 'full',
+        order_addresses: 'full',
+        payments: 'read',
+        taxes: 'read',
+        attributes: 'read',
+      }),
+      dashboard: read(),
+      settings: read(),
+      team: none(),
+      roles: none(),
+    },
+  },
+  {
+    name: 'Catalog Staff',
+    description: 'Manage products and catalog content',
+    isSystem: true,
+    isOwnerRole: false,
+    permissions: {
+      ...storePerms({
+        products: 'full',
+        collections: 'full',
+        brands: 'full',
+        product_categories: 'full',
+        attributes: 'full',
+        orders: 'read',
+        vendor_customers: 'read',
+      }),
+      dashboard: read(),
+      settings: none(),
+      team: none(),
+      roles: none(),
+    },
+  },
+  {
+    name: 'Fulfillment',
+    description: 'Orders and fulfillment',
+    isSystem: true,
+    isOwnerRole: false,
+    permissions: {
+      ...storePerms({
+        products: 'read',
+        orders: 'full',
+        order_addresses: 'full',
+        order_discounts: 'read',
+        vendor_customers: 'read',
+      }),
+      dashboard: read(),
+      settings: none(),
+      team: none(),
+      roles: none(),
+    },
+  },
+  {
+    name: 'Viewer',
+    description: 'Read-only access to store data',
+    isSystem: true,
+    isOwnerRole: false,
+    permissions: {
+      ...storePerms(Object.fromEntries(STORE_ENTITIES.map((e) => [e, 'read']))),
+      dashboard: read(),
+      settings: none(),
+      team: none(),
+      roles: none(),
+    },
+  },
+];
+
+async function insertRolePermissions(
+  queryRunner: QueryRunner,
+  vendorRoleId: number,
+  permissions: Record<string, Perm>
+): Promise<void> {
+  for (const entity of RBAC_ENTITIES) {
+    const p = permissions[entity];
+    if (!p) continue;
+    await queryRunner.query(
+      `
+      INSERT INTO "vendor_role_permissions"
+        ("vendorRoleId", "entity", "canCreate", "canRead", "canUpdate", "canDelete")
+      VALUES ($1, $2, $3, $4, $5, $6)
+      ON CONFLICT ("vendorRoleId", "entity") DO NOTHING
+      `,
+      [vendorRoleId, entity, p.c, p.r, p.u, p.d]
+    );
+  }
+}
+
+/** Seed default vendor roles + backfill vendor_users.vendorRoleId (migration-safe). */
+export async function seedVendorRolesForMigration(
+  queryRunner: QueryRunner,
+  vendorId: number
+): Promise<void> {
+  const existing = (await queryRunner.query(
+    `SELECT id, name, "isOwnerRole" FROM "vendor_roles" WHERE "vendorId" = $1 AND "deleted" = false`,
+    [vendorId]
+  )) as Array<{ id: number; name: string; isOwnerRole: boolean }>;
+
+  let ownerRoleId = 0;
+  let viewerRoleId = 0;
+
+  if (existing.length > 0) {
+    for (const r of existing) {
+      if (r.isOwnerRole) ownerRoleId = r.id;
+      if (r.name === 'Viewer') viewerRoleId = r.id;
+    }
+  } else {
+    for (const def of DEFAULT_ROLES) {
+      const inserted = (await queryRunner.query(
+        `
+        INSERT INTO "vendor_roles"
+          ("vendorId", "name", "description", "isSystem", "isOwnerRole")
+        VALUES ($1, $2, $3, $4, $5)
+        RETURNING id
+        `,
+        [vendorId, def.name, def.description, def.isSystem, def.isOwnerRole]
+      )) as Array<{ id: number }>;
+      const roleId = inserted[0]?.id;
+      if (!roleId) continue;
+      if (def.isOwnerRole) ownerRoleId = roleId;
+      if (def.name === 'Viewer') viewerRoleId = roleId;
+      await insertRolePermissions(queryRunner, roleId, def.permissions);
+    }
+  }
+
+  if (ownerRoleId) {
+    await queryRunner.query(
+      `
+      UPDATE "vendor_users" vu
+      SET "vendorRoleId" = $1
+      WHERE vu."vendorId" = $2
+        AND vu."role" = 'owner'
+        AND vu."vendorRoleId" IS NULL
+      `,
+      [ownerRoleId, vendorId]
+    );
+  }
+  if (viewerRoleId) {
+    await queryRunner.query(
+      `
+      UPDATE "vendor_users" vu
+      SET "vendorRoleId" = $1
+      WHERE vu."vendorId" = $2
+        AND vu."role" = 'staff'
+        AND vu."vendorRoleId" IS NULL
+      `,
+      [viewerRoleId, vendorId]
+    );
+  }
+}

package/dist/paid-order-erp-3USEG6WL.js

@@ -0,0 +1,3 @@
+export { queueErpPaidOrderForOrderId } from './chunk-TDV6EJHV.js';
+import './chunk-SYBOCAWB.js';
+import './chunk-SHUYVCID.js';

package/dist/paid-order-erp-FSQ3GSXE.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkHF3L2GIT_cjs = require('./chunk-HF3L2GIT.cjs');
+require('./chunk-D5FBNKQM.cjs');
+require('./chunk-USNT2KNT.cjs');
+
+
+
+Object.defineProperty(exports, "queueErpPaidOrderForOrderId", {
+  enumerable: true,
+  get: function () { return chunkHF3L2GIT_cjs.queueErpPaidOrderForOrderId; }
+});

package/dist/pg-boss-service-4XF2TQ2E.js

@@ -0,0 +1,2 @@
+export { JOB_RUNNER_QUEUE, PgBossService } from './chunk-GO7PPYNU.js';
+import './chunk-SHUYVCID.js';

package/dist/pg-boss-service-L6MTF4EQ.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var chunkXQ3QUHWR_cjs = require('./chunk-XQ3QUHWR.cjs');
+require('./chunk-USNT2KNT.cjs');
+
+
+
+Object.defineProperty(exports, "JOB_RUNNER_QUEUE", {
+  enumerable: true,
+  get: function () { return chunkXQ3QUHWR_cjs.JOB_RUNNER_QUEUE; }
+});
+Object.defineProperty(exports, "PgBossService", {
+  enumerable: true,
+  get: function () { return chunkXQ3QUHWR_cjs.PgBossService; }
+});

package/dist/razorpay-KLO2KNCB.js

@@ -0,0 +1,49 @@
+import { __name } from './chunk-SHUYVCID.js';
+import Razorpay from 'razorpay';
+import crypto from 'crypto';
+
+var RazorpayPaymentService = class {
+  static {
+    __name(this, "RazorpayPaymentService");
+  }
+  razorpay;
+  keySecret;
+  webhookSecret;
+  constructor(config) {
+    this.razorpay = new Razorpay({
+      key_id: config.keyId,
+      key_secret: config.keySecret
+    });
+    this.keySecret = config.keySecret;
+    this.webhookSecret = config.webhookSecret;
+  }
+  async createPaymentIntent(amount, currency, metadata) {
+    const order = await this.razorpay.orders.create({
+      amount: Math.round(amount * 100),
+      currency: currency.toUpperCase(),
+      notes: metadata
+    });
+    return {
+      id: order.id,
+      clientSecret: order.id,
+      amount,
+      currency,
+      status: order.status
+    };
+  }
+  async capturePayment(paymentId, amount) {
+    try {
+      await this.razorpay.payments.capture(paymentId, amount ? Math.round(amount * 100) : 0, "INR");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  verifyWebhookSignature(payload, signature) {
+    const secret = this.webhookSecret || this.keySecret;
+    const expectedSignature = crypto.createHmac("sha256", secret).update(typeof payload === "string" ? payload : payload.toString("utf8")).digest("hex");
+    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+  }
+};
+
+export { RazorpayPaymentService };