@ozdao/martyrs 0.2.547 → 0.2.549

package/dist/wallet.server.js

@@ -1,511 +0,0 @@
-import * as QRCode from "qrcode";
-import { m as middlewareIndexFactory } from "./index-_Edcmck_.js";
-import { c as controllerFactory$1 } from "./tickets.controller-C8sWVqbB.js";
-import { O as ObserverNamespaced } from "./globals.observer-MZsqaE6F.js";
-import Stripe from "stripe";
-import { BigNumber } from "bignumber.js";
-import { Types } from "mongoose";
-const controllerFactory = (db) => {
-  const Payment = db.payment;
-  const Wallet = db.wallet;
-  db.order;
-  const create = async (req, res) => {
-    let { amount, positions, userId } = req.body;
-    const newPayment = new Payment(req.body);
-    await newPayment.save();
-    const qrData = `PaymentID:${newPayment._id};Amount:${amount}`;
-    const qrCode = await QRCode.toDataURL(qrData);
-    res.send({ qrCode, paymentId: newPayment._id });
-  };
-  const read = async (req, res) => {
-    try {
-      const paymentes = await Payment.find({}).sort({ createdAt: "desc" }).exec();
-      if (!paymentes) {
-        return res.status(404).send({ message: "Paymentes not found." });
-      }
-      res.status(200).send(paymentes);
-    } catch (err) {
-      res.status(500).send({ message: err.toString() });
-    }
-  };
-  const update = async (req, res) => {
-    const session = await db.mongoose.startSession();
-    session.startTransaction();
-    try {
-      const { paymentId, walletId } = req.body;
-      const payment = await Payment.findById(paymentId).session(session);
-      if (!payment) {
-        throw new Error("Payment not found");
-      }
-      if (payment.status !== "pending") {
-        throw new Error("Payment is not in a pending state");
-      }
-      const wallet = await Wallet.findById(walletId).session(session);
-      if (!wallet) {
-        throw new Error("Wallet not found");
-      }
-      if (wallet.amount < payment.amount) {
-        throw new Error("Insufficient funds");
-      }
-      wallet.amount -= payment.amount;
-      await wallet.save({ session });
-      payment.status = "completed";
-      await payment.save({ session });
-      await session.commitTransaction();
-      res.send("Payment processed successfully");
-    } catch (error) {
-      await session.abortTransaction();
-      res.status(500).send(error.message);
-    } finally {
-      session.endSession();
-    }
-  };
-  const deletePayment = (req, res) => {
-    Payment.findOneAndDelete({ _id: req.params._id }, (err, payment) => {
-      if (err) {
-        return res.status(500).send({ message: err });
-      }
-      if (!payment) {
-        return res.status(404).send({ message: "Something wrong when deleting payment." });
-      }
-      res.status(200).send(payment);
-    });
-  };
-  return {
-    create,
-    read,
-    update,
-    delete: deletePayment
-  };
-};
-class Webhook {
-  constructor(app, db, observer, path, handlerMethod, middlewares = []) {
-    this.app = app;
-    this.db = db;
-    this.observer = observer;
-    this.app.post(path, [...middlewares, handlerMethod.bind(this)]);
-  }
-  // Abstract method, must be implemented in derived classes
-  handleWebhook(req, res) {
-    throw new Error("handleWebhook() must be implemented by subclasses");
-  }
-}
-const stripe = new Stripe(process.env.STRIPE_API_KEY ?? "", {
-  apiVersion: "2025-04-30.basil"
-});
-function middleware(req, res, next) {
-  next();
-}
-class StripeWebhook extends Webhook {
-  constructor(app, db, observer, path = "/api/webhook/stripe", handlerMethod = StripeWebhook.prototype.handleWebhook, middlewares = []) {
-    super(app, db, observer, path, handlerMethod, [middleware]);
-  }
-  async handleWebhook(req, res) {
-    req.headers["stripe-signature"];
-    try {
-      const payload = req.body;
-      const payloadString = JSON.stringify(payload, null, 2);
-      const secret = process.env.STRIPE_WEBHOOK_SECRET;
-      const header = stripe.webhooks.generateTestHeaderString({
-        payload: payloadString,
-        secret
-      });
-      const event = stripe.webhooks.constructEvent(payloadString, header, secret);
-      this.observer.notify(event.type, event.data.object);
-    } catch (err) {
-      console.log(`Error verifying Stripe webhook signature: ${err.message}`);
-      return res.status(400).send(`Webhook Error: ${err.message}`);
-    }
-    res.sendStatus(200);
-  }
-}
-const RoutesPayments = function(app, db, origins, publicPath) {
-  const observer = new ObserverNamespaced();
-  new StripeWebhook(app, db, observer);
-  const controller = controllerFactory(db);
-  console.log("payments ticket", publicPath);
-  const controllerTickets = controllerFactory$1(db, publicPath);
-  middlewareIndexFactory(db);
-  observer.subscribe("checkout.session.completed", async (paymentIntent) => {
-    try {
-      const event = await db.event.findOne({ _id: paymentIntent.metadata.product });
-      if (!event) {
-        console.error("Event not found:", paymentIntent.metadata.product);
-        return;
-      }
-      const ticketType = event.ticketsTypes.find((type) => type.name === paymentIntent.metadata.ticketType);
-      if (!ticketType) {
-        console.error("Ticket type not found:", paymentIntent.metadata.ticketType);
-        return;
-      }
-      const quantity = paymentIntent.amount_total / (ticketType.price * 100);
-      console.log("Purchase details:");
-      console.log("Email:", paymentIntent.customer_details.email);
-      console.log("Name:", paymentIntent.customer_details.name);
-      console.log("Event ID:", paymentIntent.metadata.eventId);
-      console.log("Ticket Type:", ticketType.name);
-      console.log("Quantity:", quantity);
-      let ticketData = {
-        name: paymentIntent.customer_details.name,
-        email: paymentIntent.customer_details.email,
-        target: paymentIntent.metadata.product,
-        type: "event",
-        seat: ticketType.name,
-        quantity,
-        price: ticketType.price
-      };
-      await controllerTickets.saveAndSendTicket(ticketData);
-    } catch (error) {
-      console.error("Error processing checkout session:", error);
-    }
-  });
-  app.get("/api/payments/read", controller.read);
-  app.post("/api/payments/create", controller.create);
-  app.post("/api/payments/update", controller.update);
-  app.delete("/api/payments/delete", controller.delete);
-};
-const ObjectId = { Types }.Types.ObjectId;
-BigNumber.config({
-  EXPONENTIAL_AT: [-1e3, 2e3]
-});
-const VIEWS_REWARD_COEFF = "0.1";
-const WDT_DECIMALS = 8;
-const calculateRewardForPost = (snapshot, viewsCount, reactionsCount, commentsCount) => {
-  console.log("snapshot", snapshot);
-  if (snapshot) {
-    return new BigNumber(Math.max(viewsCount - snapshot.views, 0)).multipliedBy(VIEWS_REWARD_COEFF).plus(Math.max(reactionsCount - snapshot.reactions, 0)).plus(Math.max(commentsCount - snapshot.comments, 0));
-  }
-  return new BigNumber("10").plus(new BigNumber(viewsCount).multipliedBy(VIEWS_REWARD_COEFF)).plus(reactionsCount).plus(commentsCount);
-};
-const rewardsControllerFactory = (db, wdmClient, wss) => {
-  const Blogpost = db.blogpost;
-  const Reaction = db.reaction;
-  const Comment = db.comment;
-  const Reward = db.reward;
-  const Wallet = db.wallet;
-  const lookup = {};
-  wss.on("connection", (ws, req) => {
-    ws.type = "rewards";
-    if (req.userId) {
-      lookup[req.userId] = ws;
-      ws.on("close", () => {
-        delete lookup[req.userId];
-      });
-    }
-  });
-  const listRewards = async (req, res) => {
-    const userId = new ObjectId(req.userId);
-    try {
-      const aggregationResults = await Blogpost.aggregate([
-        // Соответствие блогпостов для данного пользователя
-        { $match: { "creator.target": userId } },
-        // Добавление информации о реакциях и комментариях
-        {
-          $lookup: {
-            from: "reactions",
-            localField: "_id",
-            foreignField: "target",
-            as: "reactions"
-          }
-        },
-        {
-          $lookup: {
-            from: "comments",
-            localField: "_id",
-            foreignField: "target",
-            as: "comments"
-          }
-        },
-        // Добавление информации о предыдущей награде
-        {
-          $lookup: {
-            from: "rewards",
-            let: { blogId: "$_id" },
-            pipeline: [
-              {
-                $match: {
-                  $expr: {
-                    $and: [{ $eq: ["$user", userId] }, { $eq: ["$type", "blogpost"] }, { $eq: ["$target", "$$blogId"] }]
-                  }
-                }
-              },
-              { $sort: { createdAt: -1 } },
-              { $limit: 1 }
-            ],
-            as: "previousReward"
-          }
-        },
-        // Преобразование результатов
-        {
-          $project: {
-            _id: 1,
-            user: req.userId,
-            type: "blogpost",
-            views: 1,
-            reactionsCount: { $size: "$reactions" },
-            commentsCount: { $size: "$comments" },
-            previousReward: { $arrayElemAt: ["$previousReward", 0] },
-            name: 1,
-            content: 1,
-            url: 1
-          }
-        }
-      ]);
-      const rewards = aggregationResults.map((result) => ({
-        user: result.user,
-        type: result.type,
-        amount: calculateRewardForPost(result.previousReward?.snapshot, result.views, result.reactionsCount, result.commentsCount),
-        name: result.name,
-        content: result.content,
-        url: result.url
-      }));
-      res.status(200).send(rewards);
-    } catch (error) {
-      res.status(500).send({ message: "Произошла ошибка при получении наград", error: error.message });
-    }
-  };
-  const collectTokens = async (req, res) => {
-    const blogs = await Blogpost.find({ "creator.target": req.userId }).exec();
-    let totalRewards = new BigNumber(0);
-    for (const blog of blogs) {
-      const reactions = await Reaction.countDocuments({ target: { $in: blog._id } }).exec();
-      const comments = await Comment.countDocuments({ target: { $in: blog._id } }).exec();
-      const previousReward = await Reward.findOne({
-        user: req.userId,
-        type: "blogpost",
-        target: blog._id
-      }).sort({ createdAt: -1 }).exec();
-      const reward = calculateRewardForPost(previousReward?.snapshot, blog.views, reactions, comments);
-      if (reward.gt(0)) {
-        totalRewards = totalRewards.plus(reward);
-        const snapshot = {
-          views: previousReward ? previousReward.snapshot.views < blog.views ? blog.views : previousReward.snapshot.views : blog.views,
-          reactions: previousReward ? previousReward.snapshot.reactions < reactions ? reactions : previousReward.snapshot.reactions : reactions,
-          comments: previousReward ? previousReward.snapshot.comments < comments ? comments : previousReward.snapshot.comments : comments
-        };
-        await Reward.create({
-          user: req.userId,
-          type: "blogpost",
-          target: blog._id,
-          amount: reward.toString(),
-          snapshot
-        });
-      }
-    }
-    if (totalRewards.gt(0)) {
-      await wdmClient.transfer(totalRewards.shiftedBy(WDT_DECIMALS).toString(), req.body.recipient, req.userId);
-    }
-    res.status(200).send();
-  };
-  const requestDeposit = async (req, res) => {
-    const response = await wdmClient.createDepositRequest(req.body.network, req.body.amount, req.body.token, req.userId);
-    res.status(200).send(response.data);
-  };
-  const cancelDeposit = async (req, res) => {
-    const response = await wdmClient.cancelDeposit(req.body.id, req.userId);
-    res.status(200).send(response.data);
-  };
-  const getDepositConfig = async (req, res) => {
-    const response = await wdmClient.getDepositConfig();
-    res.status(200).send(response.data);
-  };
-  const handleDepositUpdate = async (req, res) => {
-    if (req.body.status === "TRANSFER_STATUS_COMPLETED") {
-      const userWallet = await Wallet.findOne({ owner: new ObjectId(req.body.user) });
-      const amount = new BigNumber(req.body.amount).shiftedBy(-WDT_DECIMALS).dividedBy(process.env.TOKEN_EXCHANGE_RATE).toString();
-      if (userWallet) {
-        const topupIndex = userWallet.balances.findIndex((b) => b.name === "WDT");
-        if (topupIndex < 0) {
-          userWallet.balances.push({ name: "WDT", amount: +amount, locked_amount: 0 });
-        } else {
-          userWallet.balances[topupIndex] = {
-            name: "WDT",
-            amount: userWallet.balances[topupIndex].amount + +amount,
-            locked_amount: userWallet.balances[topupIndex].locked_amount
-          };
-        }
-        await userWallet.save();
-      } else {
-        await Wallet.create({
-          owner: new ObjectId(req.body.user),
-          balances: [{ name: "WDT", amount: +amount, locked_amount: 0 }]
-        });
-      }
-    }
-    if (lookup[req.body.user]) {
-      lookup[req.body.user].send(JSON.stringify(req.body));
-    }
-    res.status(200).send();
-  };
-  return {
-    listRewards,
-    collectTokens,
-    requestDeposit,
-    getDepositConfig,
-    cancelDeposit,
-    handleDepositUpdate
-  };
-};
-const RoutesRewards = (app, db, wss, wdmClient, origins) => {
-  const controller = rewardsControllerFactory(db, wdmClient, wss);
-  const { authJwt, authSecret } = middlewareIndexFactory(db);
-  app.use((req, res, next) => {
-    const origin = req.headers.origin;
-    if (origins.includes(origin)) {
-      res.setHeader("Access-Control-Allow-Origin", origin);
-    }
-    res.header("Access-Control-Allow-Headers", "x-access-token, Origin, Content-Type, Accept");
-    next();
-  });
-  app.get("/api/crypto/rewards", [authJwt.verifyToken], controller.listRewards);
-  app.post("/api/crypto/collect", [authJwt.verifyToken], controller.collectTokens);
-  app.post("/api/crypto/deposit", [authJwt.verifyToken], controller.requestDeposit);
-  app.post("/api/crypto/deposit/cancel", [authJwt.verifyToken], controller.cancelDeposit);
-  app.post("/api/crypto/deposit/update", [authSecret.verifySecret("POST", "/api/crypto/deposit/update", process.env.WDM_SECRET)], controller.handleDepositUpdate);
-  app.get("/api/crypto/deposit/config", [], controller.getDepositConfig);
-};
-const ModelPayment = (db) => {
-  const PaymentSchema = new db.mongoose.Schema(
-    {
-      data: {
-        type: Object
-      },
-      currency: {
-        type: String
-      },
-      status: {
-        type: String
-      },
-      customer: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "User"
-      },
-      creator: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: "User"
-      }
-    },
-    {
-      timestamps: {
-        currentTime: () => Date.now()
-      }
-    }
-  );
-  const Payment = db.mongoose.model("Payment", PaymentSchema);
-  return Payment;
-};
-const ModelReward = (db) => {
-  const RewardSchema = new db.mongoose.Schema(
-    {
-      user: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: () => {
-          if ((void 0).owner.type === "user") return "User";
-          if ((void 0).owner.type === "organization") return "Organization";
-        },
-        required: true
-      },
-      type: {
-        type: String,
-        enum: ["blogpost", "order"],
-        required: true
-      },
-      target: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: () => {
-          if ((void 0).owner.blogpost === "blogpost") return "Blogpost";
-          if ((void 0).owner.blogpost === "order") return "Order";
-        },
-        required: true
-      },
-      amount: {
-        type: String,
-        required: true
-      },
-      snapshot: {
-        views: {
-          type: String,
-          required: true
-        },
-        reactions: {
-          type: String,
-          required: true
-        },
-        comments: {
-          type: String,
-          required: true
-        }
-      }
-    },
-    {
-      timestamps: {
-        currentTime: () => Date.now()
-      }
-    },
-    { strict: false }
-  );
-  return db.mongoose.model("Reward", RewardSchema);
-};
-const ModelWallet = (db) => {
-  const WalletSchema = new db.mongoose.Schema(
-    {
-      owner: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: () => {
-          if ((void 0).owner.type === "user") return "User";
-          if ((void 0).owner.type === "organization") return "Organization";
-        },
-        required: true
-      },
-      balances: [
-        {
-          name: String,
-          // Name of currency
-          amount: Number,
-          // Amount
-          locked_amount: Number
-        }
-      ]
-    },
-    {
-      timestamps: {
-        currentTime: () => Date.now()
-      }
-    },
-    { strict: false }
-  );
-  return db.mongoose.model("Wallet", WalletSchema);
-};
-function initializePayments(app, db, wss, wdmClient, origins, publicPath) {
-  db.wallet = ModelWallet(db);
-  db.payment = ModelPayment(db);
-  db.reward = ModelReward(db);
-  if (app) {
-    RoutesPayments(app, db, origins, publicPath);
-  }
-}
-const models = {
-  ModelWallet,
-  ModelPayment,
-  ModelReward
-};
-const routes = {
-  RoutesPayments,
-  RoutesRewards
-};
-const controllers = {
-  FactoryPayments: controllerFactory
-};
-const wallet_server = {
-  initialize: initializePayments,
-  models,
-  routes,
-  controllers
-};
-export {
-  controllers,
-  wallet_server as default,
-  initializePayments as initialize,
-  models,
-  routes
-};

package/src/builder/modes/ssr.vite.dev.js

@@ -1,180 +0,0 @@
-import compression from 'compression';
-import fs from 'fs';
-import path from 'path';
-import { createServer as createViteServer } from 'vite';
-import { createHtmlRenderer } from '../ssr/ssr-render-html.vite.js';
-// Цвета для консоли
-const colors = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  greenBright: '\x1b[92;1m',
-  blue: '\x1b[34m',
-  blueBright: '\x1b[94m',
-  yellow: '\x1b[33m',
-  red: '\x1b[31m',
-};
-export default (function createSsrDevServer(projectRoot, { clientConfig, apiConfig, ssrConfig }) {
-  let serverInstance;
-  let viteDevServer;
-  let rendererInstance;
-  const port = process.env.PORT || 8080;
-  // Создаем рендерер для SSR
-  const createDevRenderer = onUpdate => {
-    const renderHtml = createHtmlRenderer(onUpdate);
-    return async (stuff, vite) => {
-      // Динамически импортируем входную точку SSR
-      let ssrEntry;
-      try {
-        // Используем Vite для трансформации и загрузки SSR-скрипта
-        const ssrEntryPath = ssrConfig.build.rollupOptions.input;
-        ssrEntry = await vite.ssrLoadModule(ssrEntryPath);
-      } catch (error) {
-        console.error(colors.red + 'SSR compilation error' + colors.reset);
-        console.error(error);
-        return {
-          html: `<pre>${error.stack}</pre>`,
-          statusCode: 500,
-        };
-      }
-      // Рендерим приложение с помощью SSR
-      try {
-        const { html, meta, state, statusCode } = await ssrEntry._renderApp(stuff);
-        // Получаем скрипты и стили клиентской части для вставки в HTML
-        const headTags = [];
-        const bodyTags = [];
-        // Добавляем основной скрипт клиентской части
-        bodyTags.push(`<script type="module" src="/@vite/client"></script>`);
-        const clientEntryPath = clientConfig.build.rollupOptions.input.main;
-        const relativePath = path.relative(projectRoot, clientEntryPath);
-        bodyTags.push(`<script type="module" src="/${relativePath}"></script>`);
-        const initialState = JSON.stringify(state).replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
-        // Рендерим финальный HTML
-        const completeHtml = await renderHtml({
-          appHtml: html,
-          meta,
-          head: headTags.join('\n'),
-          body: bodyTags.join('\n'),
-          initialState,
-        });
-        return { html: completeHtml, statusCode };
-      } catch (error) {
-        console.error(colors.red + 'Render error' + colors.reset);
-        console.error(error.stack);
-        return {
-          html: `<pre>${error.stack}</pre>`,
-          statusCode: 500,
-        };
-      }
-    };
-  };
-  // Функция для запуска сервера
-  const startServer = async () => {
-    if (serverInstance) {
-      serverInstance.close();
-    }
-    // Очистка кэша модулей (для CJS модулей)
-    if (typeof require !== 'undefined' && require.cache) {
-      Object.keys(require.cache).forEach(id => {
-        delete require.cache[id];
-      });
-    }
-    try {
-      // Создаем Vite Dev Server
-      if (!viteDevServer) {
-        viteDevServer = await createViteServer({
-          root: projectRoot,
-          server: {
-            middlewareMode: true,
-            hmr: {
-              port: 24678, // Используем отдельный порт для HMR
-            },
-            watch: {
-              usePolling: false, // Отключаем polling
-              ignored: ['**/node_modules/**', '**/builds/**'], // Игнорируем ненужные директории
-            },
-          },
-          appType: 'custom',
-          logLevel: 'info',
-          // Настройки для SSR
-          ssr: {
-            noExternal: [
-              // Обрабатываем только клиентские зависимости через Vite
-              'vue', 'vue-router', 'vuex', 'vue-meta', '@vue/server-renderer'
-            ],
-            external: [
-              // Исключаем серверные Node.js модули
-              'jsonwebtoken', 'bcryptjs', 'nodemailer', 'crypto'
-            ]
-          },
-          // Используем настройки из клиентского конфига
-          ...clientConfig,
-        });
-      }
-      // Создаем рендерер, если его ещё нет
-      if (!rendererInstance) {
-        rendererInstance = createDevRenderer(() => {
-          // Теперь этот callback не должен вызываться постоянно
-          console.log(colors.green + 'Template updated' + colors.reset);
-        });
-      }
-      // Динамически импортируем серверный модуль через Vite
-      const serverPath = apiConfig.build.rollupOptions.input;
-      const serverModule = await viteDevServer.ssrLoadModule(serverPath);
-      
-      if (typeof serverModule.createServer !== 'function') {
-        throw new Error("Экспорт createServer не найден");
-      }
-      
-      let { app, server, env } = await serverModule.createServer();
-      // Применяем Vite middleware
-      app.use(viteDevServer.middlewares);
-      // Middleware для SSR
-      app.use('/*', async (req, res) => {
-        try {
-          const result = await rendererInstance(
-            {
-              url: req.originalUrl,
-              cookies: req.cookies,
-              languages: req.acceptsLanguages(),
-            },
-            viteDevServer
-          );
-          res.status(result.statusCode).header('Content-Type', 'text/html; charset=utf-8').send(result.html);
-        } catch (error) {
-          console.error(colors.red + 'SSR middleware error' + colors.reset);
-          console.error(error);
-          viteDevServer.ssrFixStacktrace(error);
-          res.status(500).send(`<pre>${error.stack}</pre>`);
-        }
-      });
-      app.use(compression());
-      serverInstance = server;
-      await server.listen(port);
-      console.log(`${colors.greenBright}Server started at localhost:${port}${colors.reset}\n`);
-      // Настройка наблюдения за изменениями серверных файлов
-      const watcher = fs.watch(path.dirname(serverPath), { recursive: true });
-      let debounceTimer;
-      watcher.on('change', async (eventType, filename) => {
-        if (filename && filename.endsWith('.js')) {
-          console.log(`${colors.blue}Server file changed: ${filename}, updating...${colors.reset}`);
-          
-          // Debounce для предотвращения множественных перезагрузок
-          clearTimeout(debounceTimer);
-          debounceTimer = setTimeout(async () => {
-            try {
-              await startServer();
-            } catch (err) {
-              console.error(colors.red + 'Server restart failed' + colors.reset);
-              console.error(err);
-            }
-          }, 500);
-        }
-      });
-    } catch (err) {
-      console.error(colors.red + 'Server start failed' + colors.reset);
-      console.error(err);
-      process.exit(1);
-    }
-  };
-  return startServer;
-});