@ozdao/martyrs 0.2.486 → 0.2.488

package/dist/events.server.cjs

@@ -1,856 +0,0 @@
-"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;