@ozdao/martyrs 0.2.477 → 0.2.479

package/dist/events.server.cjs

@@ -0,0 +1,856 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const queryProcessor$1 = require("./queryProcessor-B_X680wC.cjs");
+const metadata_schema = require("./metadata.schema-RlxNv46L.cjs");
+const Stripe = require("stripe");
+const mongoose = require("mongoose");
+const tickets_controller = require("./tickets.controller-D0V0gJCA.cjs");
+const common_schema = require("./common.schema-BzFEVNn3.cjs");
+const engagement_schema = require("./engagement.schema-JADHu8pj.cjs");
+const ownership_schema = require("./ownership.schema-DCosqOc1.cjs");
+const index = require("./index-YNOkL1mu.cjs");
+const globals_abac = require("./globals.abac-Cm9e8Jdk.cjs");
+class serviceIntegrations {
+  async createProduct(event) {
+    throw new Error("createProduct method not implemented");
+  }
+  async updateProduct(event) {
+    throw new Error("updateProduct method not implemented");
+  }
+  async deactivateProduct(event) {
+    throw new Error("deactivateProduct method not implemented");
+  }
+  async createPaymentLink(event) {
+    throw new Error("createPaymentLink method not implemented");
+  }
+  async updatePaymentLink(event) {
+    throw new Error("updatePaymentLink method not implemented");
+  }
+  async deactivatePaymentLink(event) {
+    throw new Error("deactivatePaymentLink method not implemented");
+  }
+  async createСheckout(event) {
+    throw new Error("createСheckout method not implemented");
+  }
+  async deactivateСheckout(event) {
+    throw new Error("deactivateСheckout method not implemented");
+  }
+  async createRefund(event) {
+    throw new Error("createRefund method not implemented");
+  }
+  async updateRefund(event) {
+    throw new Error("updateRefund method not implemented");
+  }
+  async deactivateRefund(event) {
+    throw new Error("deactivateRefund method not implemented");
+  }
+}
+const stripe = new Stripe(process.env.STRIPE_API_KEY ?? "", {
+  apiVersion: "2025-04-30.basil"
+});
+class servicePaymentStripe extends serviceIntegrations {
+  async createProducts(entityId, items, eventName) {
+    const product = await stripe.products.create({
+      id: entityId,
+      name: eventName,
+      metadata: {
+        product: entityId
+      }
+    });
+    const priceLinks = [];
+    for (const item of items) {
+      const price = await stripe.prices.create({
+        product: product.id,
+        unit_amount: item.price * 100,
+        currency: "THB",
+        nickname: item.name,
+        metadata: {
+          ticketType: item.name
+        }
+      });
+      const paymentLink = await stripe.paymentLinks.create({
+        line_items: [
+          {
+            price: price.id,
+            quantity: 1,
+            adjustable_quantity: {
+              enabled: true
+            }
+          }
+        ],
+        metadata: {
+          product: entityId,
+          ticketType: item.name
+        }
+      });
+      priceLinks.push({
+        productId: product.id,
+        priceId: price.id,
+        paymentLinkId: paymentLink.id,
+        paymentLink: paymentLink.url,
+        name: item.name
+      });
+    }
+    return priceLinks;
+  }
+  async updateProducts(entityId, newItems, existingItems, eventName) {
+    try {
+      const updates = [];
+      let product;
+      try {
+        product = await stripe.products.retrieve(entityId);
+      } catch (error) {
+        return this.createProducts(entityId, newItems, eventName);
+      }
+      await stripe.products.update(product.id, {
+        name: eventName
+      });
+      const deletedItems = existingItems.filter((existingItem) => !newItems.some((newItem) => newItem.name === existingItem.name));
+      for (const deletedItem of deletedItems) {
+        if (deletedItem.stripePaymentLinkId) {
+          await stripe.paymentLinks.update(deletedItem.stripePaymentLinkId, {
+            active: false
+          });
+        }
+      }
+      for (const item of newItems) {
+        const existingItem = existingItems.find((e) => e.name === item.name);
+        if (existingItem) {
+          const prices = await stripe.prices.list({
+            product: product.id,
+            active: true
+          });
+          let price = prices.data.find((p) => p.unit_amount === item.price * 100 && p.metadata?.ticketType === item.name);
+          if (!price) {
+            await Promise.all(prices.data.filter((p) => p.metadata?.ticketType === item.name).map((p) => stripe.prices.update(p.id, { active: false })));
+            price = await stripe.prices.create({
+              product: product.id,
+              unit_amount: item.price * 100,
+              currency: "THB",
+              nickname: item.name,
+              metadata: {
+                ticketType: item.name
+              }
+            });
+            if (existingItem.stripePaymentLinkId) {
+              await stripe.paymentLinks.update(existingItem.stripePaymentLinkId, {
+                active: false
+              });
+            }
+            const paymentLink = await stripe.paymentLinks.create({
+              line_items: [
+                {
+                  price: price.id,
+                  quantity: 1,
+                  adjustable_quantity: {
+                    enabled: true
+                  }
+                }
+              ],
+              metadata: {
+                product: product.id,
+                ticketType: item.name
+              }
+            });
+            updates.push({
+              productId: product.id,
+              priceId: price.id,
+              paymentLinkId: paymentLink.id,
+              paymentLink: paymentLink.url,
+              name: item.name
+            });
+          } else {
+            updates.push({
+              productId: product.id,
+              priceId: price.id,
+              paymentLinkId: existingItem.stripePaymentLinkId,
+              paymentLink: existingItem.link,
+              name: item.name
+            });
+          }
+        } else {
+          const price = await stripe.prices.create({
+            product: product.id,
+            unit_amount: item.price * 100,
+            currency: "THB",
+            nickname: item.name,
+            metadata: {
+              ticketType: item.name
+            }
+          });
+          const paymentLink = await stripe.paymentLinks.create({
+            line_items: [
+              {
+                price: price.id,
+                quantity: 1,
+                adjustable_quantity: {
+                  enabled: true
+                }
+              }
+            ],
+            metadata: {
+              product: product.id,
+              ticketType: item.name
+            }
+          });
+          updates.push({
+            productId: product.id,
+            priceId: price.id,
+            paymentLinkId: paymentLink.id,
+            paymentLink: paymentLink.url,
+            name: item.name
+          });
+        }
+      }
+      return updates;
+    } catch (error) {
+      console.error("Error updating products:", error);
+      throw error;
+    }
+  }
+  async deactivateProduct(productId) {
+    try {
+      await stripe.products.update(productId, {
+        active: false
+      });
+      const prices = await stripe.prices.list({
+        product: productId,
+        active: true
+      });
+      await Promise.all(prices.data.map((price) => stripe.prices.update(price.id, { active: false })));
+      const paymentLinks = await stripe.paymentLinks.list({
+        metadata: {
+          product: productId
+        }
+      });
+      await Promise.all(paymentLinks.data.map((link) => stripe.paymentLinks.update(link.id, { active: false })));
+      return true;
+    } catch (error) {
+      console.error("Error deactivating product:", error);
+      throw error;
+    }
+  }
+  async createСheckout(event) {
+    const session = await stripe.checkout.sessions.create({
+      payment_method_types: ["card"],
+      line_items: event.variants.map((variant) => ({
+        price: variant.priceId,
+        quantity: variant.quantity
+      })),
+      mode: "payment",
+      success_url: event.successUrl,
+      cancel_url: event.cancelUrl
+    });
+    return session.url;
+  }
+  async deactivateСheckout(sessionId) {
+    await stripe.checkout.sessions.expire(sessionId);
+    return "Payment session expired.";
+  }
+  async createRefund(event) {
+    const refund = await stripe.refunds.create({
+      payment_intent: event.paymentIntentId
+    });
+    return refund;
+  }
+  async updateRefund(refundId, metadata) {
+    try {
+      const refund = await stripe.refunds.update(refundId, {
+        metadata
+      });
+      return refund;
+    } catch (error) {
+      throw new Error("Failed to update refund: " + error.message);
+    }
+  }
+  async deactivateRefund(refundId) {
+    try {
+      const refund = await stripe.refunds.cancel(refundId);
+      return refund;
+    } catch (error) {
+      throw new Error("Failed to cancel refund: " + error.message);
+    }
+  }
+}
+const ObjectId = { Types: mongoose.Types }.Types.ObjectId;
+function getDateConditions(date) {
+  if (date) {
+    const dateString = date.toString();
+    const day = parseInt(dateString.substring(0, 2), 10);
+    const month = parseInt(dateString.substring(2, 4), 10) - 1;
+    const year = parseInt(dateString.substring(4, 8), 10);
+    const customDate = new Date(year, month, day);
+    customDate.setHours(0, 0, 0, 0);
+    const customDateEnd = new Date(year, month, day);
+    customDateEnd.setHours(23, 59, 59, 999);
+    return [{ $match: { "date.start": { $gte: customDate, $lte: customDateEnd } } }];
+  } else {
+    return [];
+  }
+}
+function getPeriodConditions(period, periodStart, periodEnd) {
+  const now = /* @__PURE__ */ new Date();
+  let startDate, endDate;
+  if (periodStart && periodEnd) {
+    startDate = new Date(periodStart);
+    endDate = new Date(periodEnd);
+    return [
+      {
+        $match: {
+          "date.start": {
+            $gte: startDate,
+            $lte: endDate
+          }
+        }
+      }
+    ];
+  } else if (period) {
+    startDate = new Date(now.getTime());
+    endDate = new Date(now.getTime());
+    switch (period) {
+      case "today":
+        startDate.setHours(0, 0, 0, 0);
+        endDate.setHours(23, 59, 59, 999);
+        break;
+      case "week":
+        endDate.setDate(now.getDate() + 7);
+        break;
+      case "month":
+        endDate.setDate(now.getDate() + 30);
+        break;
+      case "year":
+        endDate.setFullYear(now.getFullYear() + 1);
+        break;
+    }
+    return [
+      {
+        $match: {
+          "date.start": {
+            $gte: startDate,
+            $lte: endDate
+          }
+        }
+      }
+    ];
+  } else {
+    return [];
+  }
+}
+function getPhaseConditions(phase) {
+  const now = /* @__PURE__ */ new Date();
+  const todayStart = new Date(now.getTime());
+  todayStart.setHours(0, 0, 0, 0);
+  const todayEnd = new Date(now.getTime());
+  todayEnd.setHours(23, 59, 59, 999);
+  let matchConditions = [];
+  switch (phase) {
+    case "finished":
+      matchConditions.push({ "date.start": { $lt: now } });
+      break;
+    case "today":
+      matchConditions.push({ "date.start": { $gte: todayStart, $lte: todayEnd } });
+      break;
+    case "live":
+      matchConditions.push({ "date.start": { $lte: now } });
+      matchConditions.push({ "date.end": { $gte: now } });
+      break;
+    case "planned":
+      matchConditions.push({ "date.start": { $gt: now } });
+      break;
+  }
+  if (matchConditions && matchConditions.length > 0) {
+    return [{ $match: { $and: matchConditions } }];
+  } else {
+    return [];
+  }
+}
+function getTicketsLookupStage() {
+  return {
+    $lookup: {
+      from: "tickets",
+      localField: "_id",
+      foreignField: "target",
+      as: "tickets",
+      pipeline: [
+        {
+          $lookup: {
+            from: "users",
+            localField: "user",
+            foreignField: "_id",
+            as: "user"
+          }
+        },
+        {
+          $unwind: { path: "$user", preserveNullAndEmptyArrays: true }
+        }
+      ]
+    }
+  };
+}
+function getParticipantsPhotosStage() {
+  return {
+    $addFields: {
+      participantsPhotos: {
+        $map: {
+          input: "$tickets",
+          as: "ticket",
+          in: "$$ticket.user.profile.photo"
+        }
+      }
+    }
+  };
+}
+function getNumberOfTicketsStage() {
+  return {
+    $addFields: {
+      numberOfTickets: { $size: "$tickets" }
+    }
+  };
+}
+function getHasTicketStage(user) {
+  if (user) {
+    return [
+      {
+        $addFields: {
+          hasTicket: {
+            $in: [new ObjectId(user), "$tickets.user._id"]
+          }
+        }
+      }
+    ];
+  } else {
+    return [];
+  }
+}
+function getProjectStage() {
+  return {
+    $project: {
+      _id: 1,
+      url: 1,
+      cover: 1,
+      name: 1,
+      phase: 1,
+      description: 1,
+      content: 1,
+      owner: 1,
+      creator: 1,
+      tags: 1,
+      date: 1,
+      numberOfTickets: 1,
+      participantsPhotos: 1,
+      special: 1,
+      specialData: 1,
+      hasTicket: 1,
+      tickets: 1,
+      createdAt: 1
+    }
+  };
+}
+function getParticipantStages(participantQuery) {
+  const participantId = participantQuery ? new ObjectId(participantQuery) : null;
+  let stages = [];
+  if (participantId) {
+    stages.push({
+      $addFields: {
+        participantTickets: {
+          $filter: {
+            input: "$tickets",
+            as: "ticket",
+            cond: { $eq: ["$$ticket.user._id", participantId] }
+          }
+        }
+      }
+    });
+    stages.push({
+      $match: {
+        "participantTickets.0": { $exists: true }
+      }
+    });
+  }
+  return stages;
+}
+const queryProcessor = {
+  getDateConditions,
+  getPhaseConditions,
+  getPeriodConditions,
+  getTicketsLookupStage,
+  getParticipantsPhotosStage,
+  getNumberOfTicketsStage,
+  getHasTicketStage,
+  getProjectStage,
+  getParticipantStages
+};
+({ Types: mongoose.Types }).Types.ObjectId;
+const middlewareFactory$1 = (db) => {
+  db.ticket;
+  const Event = db.event;
+  db.membership;
+  const serviceStripe = new servicePaymentStripe();
+  const read = async (req, res) => {
+    console.log("req is", req.query);
+    let stages = [];
+    stages = [
+      ...queryProcessor$1.queryProcessorGlobals.getSearchOptions(req.query.search, {
+        fields: ["name"]
+      }),
+      ...queryProcessor$1.queryProcessorGlobals.getBasicOptions(req.query),
+      ...queryProcessor.getDateConditions(req.query.date),
+      ...queryProcessor.getPeriodConditions(req.query.period, req.query.periodStart, req.query.periodEnd),
+      ...queryProcessor.getPhaseConditions(req.query.phase),
+      // Tickets and Participants
+      queryProcessor.getTicketsLookupStage(),
+      queryProcessor.getParticipantsPhotosStage(),
+      queryProcessor.getNumberOfTicketsStage(),
+      ...queryProcessor.getHasTicketStage(req.query.user),
+      ...queryProcessor.getParticipantStages(req.query.participant),
+      // For creator
+      queryProcessor$1.queryProcessorGlobals.getCreatorUserLookupStage(),
+      queryProcessor$1.queryProcessorGlobals.getCreatorOrganizationLookupStage(),
+      // For owner
+      queryProcessor$1.queryProcessorGlobals.getOwnerUserLookupStage(),
+      queryProcessor$1.queryProcessorGlobals.getOwnerOrganizationLookupStage(),
+      queryProcessor$1.queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
+      // Get object
+      // queryProcessor.getProjectStage(),
+      // Pagination
+      ...queryProcessor$1.queryProcessorGlobals.getSortingOptions(req.query.sortParam, req.query.sortOrder),
+      ...queryProcessor$1.queryProcessorGlobals.getPaginationOptions(req.query.skip, req.query.limit)
+    ];
+    try {
+      const events = await Event.aggregate(stages).exec();
+      res.status(200).send(events);
+    } catch (err) {
+      console.log(err);
+      return res.status(500).send({
+        message: err
+      });
+    }
+  };
+  const create = async (req, res) => {
+    delete req.body._id;
+    try {
+      req.body.url = metadata_schema.createFriendlyURL(req.body.name);
+      let event = new Event(req.body);
+      if (!event) {
+        return res.status(404).send({ message: "Event is not created." });
+      }
+      if (event.ticketsTypes && event.ticketsTypes.length > 0) {
+        const stripeProducts = await serviceStripe.createProducts(event._id.toString(), event.ticketsTypes, event.name);
+        event.ticketsTypes = event.ticketsTypes.map((ticket, index2) => ({
+          ...ticket,
+          stripeProductId: stripeProducts[index2].productId,
+          stripePriceId: stripeProducts[index2].priceId,
+          stripePaymentLinkId: stripeProducts[index2].paymentLinkId,
+          link: stripeProducts[index2].paymentLink
+        }));
+      }
+      await event.save();
+      res.status(200).send(event);
+    } catch (err) {
+      console.log(err);
+      return res.status(500).send({
+        message: err.message
+      });
+    }
+  };
+  const update = async (req, res) => {
+    try {
+      let existingEvent = await Event.findOne({ url: req.body.url });
+      if (!existingEvent) {
+        return res.status(404).send({
+          message: "Event not found."
+        });
+      }
+      if (req.body.ticketsTypes && req.body.ticketsTypes.length > 0) {
+        const stripeUpdates = await serviceStripe.updateProducts(existingEvent._id.toString(), req.body.ticketsTypes, existingEvent.ticketsTypes || [], req.body.name);
+        req.body.ticketsTypes = req.body.ticketsTypes.map((ticket) => {
+          const stripeData = stripeUpdates.find((update2) => update2.name === ticket.name);
+          return {
+            ...ticket,
+            stripeProductId: stripeData?.productId,
+            stripePriceId: stripeData?.priceId,
+            stripePaymentLinkId: stripeData?.paymentLinkId,
+            link: stripeData?.paymentLink || ticket.link
+          };
+        });
+      } else {
+        req.body.ticketsTypes = [];
+      }
+      await Event.updateOne({ _id: existingEvent._id }, { $set: req.body });
+      res.status(200).send(req.body);
+    } catch (err) {
+      console.log(err);
+      return res.status(500).send({
+        message: err.message
+      });
+    }
+  };
+  const deleteMethod = async (req, res) => {
+    try {
+      const event = await Event.findOne({ _id: req.body._id });
+      if (!event) {
+        return res.status(404).send({
+          message: "Event not found."
+        });
+      }
+      if (event.ticketsTypes && event.ticketsTypes.length > 0) {
+        await serviceStripe.deactivateProduct(event._id.toString());
+      }
+      await Event.deleteOne({ _id: req.body._id });
+      res.status(200).send(event);
+    } catch (err) {
+      return res.status(500).send({
+        message: err.message
+      });
+    }
+  };
+  return {
+    read,
+    create,
+    update,
+    delete: deleteMethod
+  };
+};
+const createEventModel = (db, additionalFields = {}) => {
+  const baseSchema = {
+    cover: {
+      type: String
+    },
+    name: {
+      type: String,
+      required: true
+    },
+    description: {
+      type: String,
+      required: true
+    },
+    location: {
+      type: String
+    },
+    content: {
+      type: Array
+    },
+    date: {
+      start: {
+        type: Date,
+        required: true
+      },
+      end: {
+        type: Date
+      }
+    },
+    ticketsTypes: {
+      type: Array
+    }
+    // ticketsTypes: [{
+    //     image: String,
+    //     link: String,
+    //     price: Number,
+    //     name: String,
+    //     buttonText: String
+    //     stripeProductId
+    //     stripePriceId
+    //     stripePaymentLinkId
+    // }]
+  };
+  const EventSchema = new db.mongoose.Schema(
+    {
+      ...baseSchema,
+      ...additionalFields
+    },
+    {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    }
+  );
+  EventSchema.index({
+    name: 1,
+    "date.start": 1,
+    "date.end": -1
+  });
+  common_schema.applyCommonSchema(EventSchema);
+  engagement_schema.applyEngagementSchema(EventSchema);
+  ownership_schema.applyOwnershipSchema(EventSchema, db);
+  metadata_schema.applyMetadataSchema(EventSchema);
+  return db.mongoose.model("Event", EventSchema);
+};
+const createTicketModel = (db) => {
+  const TicketSchema = new db.mongoose.Schema(
+    {
+      client: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "Client"
+      },
+      client_refactor: {
+        email: {
+          type: String
+        },
+        name: {
+          type: String
+        }
+      },
+      seat: {
+        type: String
+      },
+      price: {
+        type: Number
+      },
+      user: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: "User"
+      },
+      type: {
+        type: String,
+        enum: ["event", "parking"],
+        default: "event",
+        required: true
+      },
+      target: {
+        type: db.mongoose.Schema.Types.ObjectId,
+        ref: function(value) {
+          if (this.type === "event") return "Event";
+          if (this.type === "parking") return "Parking";
+        },
+        required: true
+      },
+      role: {
+        type: String,
+        default: "participant"
+      },
+      qrcode: {
+        type: String
+      },
+      image: {
+        type: String
+      },
+      status: {
+        type: String,
+        enum: ["unused", "used", "deactivated"],
+        deafult: "unused"
+      }
+    },
+    {
+      timestamps: {
+        currentTime: () => Date.now()
+      }
+    }
+  );
+  TicketSchema.index({ user: 1, type: 1, target: 1 });
+  const Ticket = db.mongoose.model("Ticket", TicketSchema);
+  return Ticket;
+};
+const middlewareFactory = (db) => {
+  const Event = db.event;
+  const checkEventExistOrNot = async (req, res, next) => {
+    try {
+      const url = req.body.url ? req.body.url : req.body.name.toLowerCase().replace(/ /g, "-").replace(/[^\w-]+/g, "");
+      if (!req.body._id) {
+        const event = await Event.findOne({ url });
+        if (event) {
+          res.status(400).send({ errorCode: "EVENT_URL_ALREADY_IN_USE", accessToken: null });
+          return;
+        }
+        next();
+        return;
+      }
+      const updatingEventId = req.body._id;
+      const existingEvent = await Event.findById(updatingEventId);
+      if (!existingEvent) {
+        res.status(404).send({ errorCode: "EVENT_NOT_FOUND", accessToken: null });
+        return;
+      }
+      if (existingEvent.url !== url) {
+        const event = await Event.findOne({ url });
+        if (event) {
+          res.status(400).send({ errorCode: "EVENT_URL_ALREADY_IN_USE", accessToken: null });
+          return;
+        }
+      }
+      next();
+    } catch (err) {
+      console.log(err);
+      res.status(500).send({ message: err });
+    }
+  };
+  const checkNameNotEmpty = (req, res, next) => {
+    if (!req.body.name || req.body.name.trim() === "") {
+      res.status(400).send({ errorCode: "NAME_CANNOT_BE_EMPTY", accessToken: null });
+      return;
+    }
+    next();
+  };
+  return {
+    checkEventExistOrNot,
+    // Изменено с checkBlogpostExistOrNot на checkEventExistOrNot
+    checkNameNotEmpty
+  };
+};
+const middlewareIndexFactory = (db) => {
+  const verifyEvent = middlewareFactory(db);
+  return {
+    verifyEvent
+  };
+};
+const { getInstance } = globals_abac.globalsabac;
+const eventsRoutes = function(app, db, origins) {
+  const controller = middlewareFactory$1(db);
+  const abac = getInstance(db);
+  const { authJwt } = index.middlewareIndexFactory(db);
+  const { verifyEvent } = middlewareIndexFactory(db);
+  app.get(
+    "/api/events/read",
+    [
+      authJwt.verifyToken(true),
+      abac.middleware("events", "read", {
+        allowPublished: true,
+        allowUnauthenticated: true
+      })
+    ],
+    controller.read
+  );
+  app.post("/api/events/create", [authJwt.verifyToken(), abac.middleware("events", "create"), verifyEvent.checkNameNotEmpty, verifyEvent.checkEventExistOrNot], controller.create);
+  app.post("/api/events/update", [authJwt.verifyToken(), abac.middleware("events", "edit"), verifyEvent.checkNameNotEmpty, verifyEvent.checkEventExistOrNot], controller.update);
+  app.post("/api/events/delete", [authJwt.verifyToken(), abac.middleware("events", "delete")], controller.delete);
+};
+const ticketsRoutes = function(app, db, origins, publicPath) {
+  const controller = tickets_controller.controllerFactory(db, publicPath);
+  app.get("/api/tickets", controller.read);
+  app.post("/api/tickets/create", controller.create);
+  app.post("/api/tickets/update", controller.update);
+  app.post("/api/tickets/delete", controller.delete);
+};
+function initializeEvent(app, db, origins, publicPath, options = {}) {
+  console.log("initializeEvent publicPath:", publicPath);
+  const { eventFields = {}, ticketFields = {} } = options;
+  console.log("new fields is", eventFields);
+  db.event = createEventModel(db, eventFields);
+  db.ticket = createTicketModel(db);
+  if (app) {
+    eventsRoutes(app, db);
+    ticketsRoutes(app, db, origins, publicPath);
+  }
+}
+const models = {
+  EventModel: createEventModel,
+  TicketModel: createTicketModel
+};
+const routes = {
+  eventsRoutes,
+  ticketsRoutes
+};
+const controllers = {
+  EventsController: middlewareFactory$1,
+  TicketsController: tickets_controller.controllerFactory
+};
+const events_server = {
+  initialize: initializeEvent,
+  models,
+  routes,
+  controllers
+};
+exports.controllers = controllers;
+exports.default = events_server;
+exports.initialize = initializeEvent;
+exports.models = models;
+exports.routes = routes;