@ozdao/martyrs 0.2.492 → 0.2.493

package/dist/globals.server.cjs

@@ -1,7 +1,326 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const abac = require("./abac-6LjoG9u-.cjs");
-const globals_websocket = require("./globals.websocket-k6_B1T7k.cjs");
+const cookie = require("cookie");
+const jwt = require("jsonwebtoken");
+const uWS = require("uWebSockets.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const cookie__namespace = /* @__PURE__ */ _interopNamespaceDefault(cookie);
+class WebSocketManager {
+  constructor() {
+    this.app = uWS.App();
+    this.modules = /* @__PURE__ */ new Map();
+    this.userConnections = /* @__PURE__ */ new Map();
+    this.rpcMethods = /* @__PURE__ */ new Map();
+    this.app.ws("/api/ws", {
+      maxPayloadLength: 16 * 1024 * 1024,
+      idleTimeout: 120,
+      compression: uWS.SHARED_COMPRESSOR,
+      maxBackpressure: 1024 * 1024,
+      // Обработчик аутентификации и апгрейда соединения
+      upgrade: (res, req, context) => {
+        let userId = null;
+        const headers = {};
+        req.forEach((key, value) => {
+          headers[key.toLowerCase()] = value;
+        });
+        const secWebSocketKey = headers["sec-websocket-key"] || "";
+        const secWebSocketProtocol = headers["sec-websocket-protocol"] || "";
+        const secWebSocketExtensions = headers["sec-websocket-extensions"] || "";
+        try {
+          if (headers.cookie) {
+            const cookies = cookie__namespace.parse(headers.cookie);
+            if (cookies.user) {
+              const token = JSON.parse(decodeURIComponent(cookies.user));
+              const decoded = jwt.verify(token.accessToken, process.env.SECRET_KEY);
+              userId = decoded._id;
+            }
+          }
+        } catch (err) {
+          console.error("Invalid token:", err);
+        }
+        if (process.env.REQUIRE_AUTH === "true" && !userId) {
+          res.writeStatus("401 Unauthorized").end("Authentication required");
+          return;
+        }
+        const userData = { userId };
+        res.upgrade(userData, secWebSocketKey, secWebSocketProtocol, secWebSocketExtensions, context);
+      },
+      // Обработчик открытия соединения
+      open: (ws) => {
+        ws.userId = ws.getUserData().userId;
+        ws.subscriptions = /* @__PURE__ */ new Set();
+        if (ws.userId) {
+          this._trackUserConnection(ws.userId, ws);
+        }
+      },
+      // Обработчик входящих сообщений
+      message: async (ws, message, isBinary) => {
+        if (!isBinary) {
+          try {
+            const msgStr = new TextDecoder().decode(message);
+            const msg = JSON.parse(msgStr);
+            if (msg.type === "subscribe" && msg.module && this.modules.has(msg.module)) {
+              ws.subscriptions.add(msg.module);
+              return;
+            } else if (msg.type === "unsubscribe" && msg.module) {
+              ws.subscriptions.delete(msg.module);
+              return;
+            }
+            if (msg.type === "rpc") {
+              await this._handleRpcCall(ws, msg);
+              return;
+            }
+            const moduleName = msg.module;
+            if (moduleName && this.modules.has(moduleName)) {
+              const handler = this.modules.get(moduleName);
+              Promise.resolve(handler(ws, msg)).catch((err) => {
+                console.error(`Error in handler for module ${moduleName}:`, err);
+              });
+            }
+          } catch (err) {
+            console.error("Invalid message or handler error:", err);
+            if (err instanceof Error) {
+              try {
+                ws.send(
+                  JSON.stringify({
+                    type: "error",
+                    error: {
+                      message: err.message,
+                      code: err.code || "INTERNAL_ERROR"
+                    }
+                  }),
+                  false
+                );
+              } catch (sendErr) {
+                console.error("Error sending error response:", sendErr);
+              }
+            }
+          }
+        }
+      },
+      // Обработчик закрытия соединения
+      close: (ws, code, message) => {
+        const userId = ws.userId;
+        if (userId && this.userConnections.has(userId)) {
+          this.userConnections.get(userId).delete(ws);
+          if (this.userConnections.get(userId).size === 0) {
+            this.userConnections.delete(userId);
+          }
+        }
+        if (ws.subscriptions && typeof ws.subscriptions.clear === "function") {
+          ws.subscriptions.clear();
+        }
+      }
+    });
+    this.listenSocket = null;
+  }
+  // Метод для запуска сервера
+  listen(port, callback) {
+    this.app.listen(port, (listenSocket) => {
+      if (listenSocket) {
+        this.listenSocket = listenSocket;
+        if (callback) callback(null, this.app);
+      } else {
+        if (callback) callback(new Error("Failed to listen"), null);
+      }
+    });
+    return this;
+  }
+  _trackUserConnection(userId, ws) {
+    if (!this.userConnections.has(userId)) {
+      this.userConnections.set(userId, /* @__PURE__ */ new Set());
+    }
+    this.userConnections.get(userId).add(ws);
+  }
+  registerModule(moduleName, handler) {
+    this.modules.set(moduleName, handler);
+  }
+  // Добавляем методы для регистрации RPC
+  registerRpcMethod(moduleName, methodName, handler, options = {}) {
+    const fullMethodName = `${moduleName}.${methodName}`;
+    if (!this.rpcMethods.has(moduleName)) {
+      this.rpcMethods.set(moduleName, /* @__PURE__ */ new Map());
+    }
+    this.rpcMethods.get(moduleName).set(methodName, {
+      handler,
+      options: {
+        requireAuth: options.requireAuth !== false,
+        // По умолчанию true
+        validateParams: options.validateParams || null,
+        rateLimit: options.rateLimit || null,
+        ...options
+      }
+    });
+    console.log(`RPC method registered: ${fullMethodName}`);
+    return this;
+  }
+  // Метод для регистрации группы RPC методов из модуля
+  registerRpcMethods(moduleName, methodsMap) {
+    for (const [methodName, config] of Object.entries(methodsMap)) {
+      const handler = typeof config === "function" ? config : config.handler;
+      const options = typeof config === "function" ? {} : config.options || {};
+      this.registerRpcMethod(moduleName, methodName, handler, options);
+    }
+    return this;
+  }
+  // Обработчик RPC вызовов
+  async _handleRpcCall(ws, message) {
+    const { module: module2, method, params, id } = message;
+    if (!this.rpcMethods.has(module2) || !this.rpcMethods.get(module2).has(method)) {
+      this._sendRpcResponse(ws, id, null, {
+        code: -32601,
+        message: `Method ${module2}.${method} not found`
+      });
+      return;
+    }
+    const { handler, options } = this.rpcMethods.get(module2).get(method);
+    if (options.requireAuth && !ws.userId) {
+      this._sendRpcResponse(ws, id, null, {
+        code: -32e3,
+        message: "Authentication required"
+      });
+      return;
+    }
+    if (options.validateParams && !options.validateParams(params)) {
+      this._sendRpcResponse(ws, id, null, {
+        code: -32602,
+        message: "Invalid params"
+      });
+      return;
+    }
+    try {
+      const context = {
+        userId: ws.userId,
+        ws,
+        sendResponse: (result2) => this._sendRpcResponse(ws, id, result2),
+        sendError: (error) => this._sendRpcResponse(ws, id, null, error)
+      };
+      const result = await handler.call(context, params, context);
+      if (!context.responseSent) {
+        this._sendRpcResponse(ws, id, result);
+      }
+    } catch (error) {
+      console.error(`Error executing RPC method ${module2}.${method}:`, error);
+      this._sendRpcResponse(ws, id, null, {
+        code: -32603,
+        message: error.message || "Internal error"
+      });
+    }
+  }
+  // Отправка ответа на RPC запрос
+  _sendRpcResponse(ws, id, result, error = null) {
+    if (ws.context?.responseSent) return;
+    if (ws.context) ws.context.responseSent = true;
+    const response = {
+      type: "rpc_response",
+      id
+    };
+    if (error) {
+      response.error = {
+        code: error.code || -32603,
+        message: error.message || "Internal error",
+        data: error.data
+      };
+    } else {
+      response.result = result;
+    }
+    try {
+      ws.send(JSON.stringify(response), false);
+    } catch (err) {
+      console.error("Error sending RPC response:", err);
+    }
+  }
+  sendToUserInModule(moduleName, userId, data) {
+    const userIdStr = userId.toString();
+    const sockets = this.userConnections.get(userIdStr);
+    if (!sockets) {
+      console.log(`No sockets found for user ${userIdStr}`);
+      return false;
+    }
+    let sent = false;
+    const message = JSON.stringify(data);
+    for (const ws of sockets) {
+      if (ws.subscriptions.has(moduleName)) {
+        try {
+          const ok = ws.send(message, false);
+          if (!ok) {
+            console.warn("WebSocket backpressure exceeded for user:", userIdStr);
+          } else {
+            sent = true;
+          }
+        } catch (err) {
+          console.warn("Failed to send message to user:", userIdStr, err);
+        }
+      }
+    }
+    return sent;
+  }
+  broadcastToModule(moduleName, data) {
+    const message = JSON.stringify(data);
+    let failedSends = 0;
+    for (const sockets of this.userConnections.values()) {
+      for (const ws of sockets) {
+        if (ws.subscriptions.has(moduleName)) {
+          try {
+            const ok = ws.send(message, false);
+            if (!ok) {
+              failedSends++;
+            }
+          } catch (err) {
+            failedSends++;
+            console.warn("Failed to broadcast message:", err);
+          }
+        }
+      }
+    }
+    if (failedSends > 0) {
+      console.warn(`Failed to send broadcast to ${failedSends} connections due to backpressure or closed sockets`);
+    }
+    return true;
+  }
+  broadcastToModuleWithFilter(moduleName, filterFn, data) {
+    const message = JSON.stringify(data);
+    let failedSends = 0;
+    for (const sockets of this.userConnections.values()) {
+      for (const ws of sockets) {
+        if (!ws.subscriptions.has(moduleName)) continue;
+        if (!filterFn(ws)) continue;
+        try {
+          const ok = ws.send(message, false);
+          if (!ok) {
+            failedSends++;
+          }
+        } catch (err) {
+          failedSends++;
+          console.warn("Failed to send filtered broadcast:", err);
+        }
+      }
+    }
+    if (failedSends > 0) {
+      console.warn(`Failed to send filtered broadcast to ${failedSends} connections due to backpressure or closed sockets`);
+    }
+    return true;
+  }
+  getServer() {
+    return this.app;
+  }
+}
 const initGlobalsPolicies = function initializeDefaultPolicies(abacAccessControl) {
   abacAccessControl.registerGlobalPolicy("AdminModeratorAccessPolicy", async (context) => {
     const { user, req } = context;
@@ -120,8 +439,8 @@ function initializeGlobals(app, db, origins, publicPath) {
 }
 const globals_server = {
   initialize: initializeGlobals,
-  WebSocketManager: globals_websocket.WebSocketManager
+  WebSocketManager
 };
-exports.WebSocketManager = globals_websocket.WebSocketManager;
+exports.WebSocketManager = WebSocketManager;
 exports.default = globals_server;
 exports.initialize = initializeGlobals;

package/dist/globals.server.js

@@ -1,5 +1,307 @@
 import { A as ABAC } from "./abac-Cf_9lCSh.js";
-import { W as WebSocketManager } from "./globals.websocket-DzvdIBf6.js";
+import * as cookie from "cookie";
+import jwt from "jsonwebtoken";
+import uWS from "uWebSockets.js";
+class WebSocketManager {
+  constructor() {
+    this.app = uWS.App();
+    this.modules = /* @__PURE__ */ new Map();
+    this.userConnections = /* @__PURE__ */ new Map();
+    this.rpcMethods = /* @__PURE__ */ new Map();
+    this.app.ws("/api/ws", {
+      maxPayloadLength: 16 * 1024 * 1024,
+      idleTimeout: 120,
+      compression: uWS.SHARED_COMPRESSOR,
+      maxBackpressure: 1024 * 1024,
+      // Обработчик аутентификации и апгрейда соединения
+      upgrade: (res, req, context) => {
+        let userId = null;
+        const headers = {};
+        req.forEach((key, value) => {
+          headers[key.toLowerCase()] = value;
+        });
+        const secWebSocketKey = headers["sec-websocket-key"] || "";
+        const secWebSocketProtocol = headers["sec-websocket-protocol"] || "";
+        const secWebSocketExtensions = headers["sec-websocket-extensions"] || "";
+        try {
+          if (headers.cookie) {
+            const cookies = cookie.parse(headers.cookie);
+            if (cookies.user) {
+              const token = JSON.parse(decodeURIComponent(cookies.user));
+              const decoded = jwt.verify(token.accessToken, process.env.SECRET_KEY);
+              userId = decoded._id;
+            }
+          }
+        } catch (err) {
+          console.error("Invalid token:", err);
+        }
+        if (process.env.REQUIRE_AUTH === "true" && !userId) {
+          res.writeStatus("401 Unauthorized").end("Authentication required");
+          return;
+        }
+        const userData = { userId };
+        res.upgrade(userData, secWebSocketKey, secWebSocketProtocol, secWebSocketExtensions, context);
+      },
+      // Обработчик открытия соединения
+      open: (ws) => {
+        ws.userId = ws.getUserData().userId;
+        ws.subscriptions = /* @__PURE__ */ new Set();
+        if (ws.userId) {
+          this._trackUserConnection(ws.userId, ws);
+        }
+      },
+      // Обработчик входящих сообщений
+      message: async (ws, message, isBinary) => {
+        if (!isBinary) {
+          try {
+            const msgStr = new TextDecoder().decode(message);
+            const msg = JSON.parse(msgStr);
+            if (msg.type === "subscribe" && msg.module && this.modules.has(msg.module)) {
+              ws.subscriptions.add(msg.module);
+              return;
+            } else if (msg.type === "unsubscribe" && msg.module) {
+              ws.subscriptions.delete(msg.module);
+              return;
+            }
+            if (msg.type === "rpc") {
+              await this._handleRpcCall(ws, msg);
+              return;
+            }
+            const moduleName = msg.module;
+            if (moduleName && this.modules.has(moduleName)) {
+              const handler = this.modules.get(moduleName);
+              Promise.resolve(handler(ws, msg)).catch((err) => {
+                console.error(`Error in handler for module ${moduleName}:`, err);
+              });
+            }
+          } catch (err) {
+            console.error("Invalid message or handler error:", err);
+            if (err instanceof Error) {
+              try {
+                ws.send(
+                  JSON.stringify({
+                    type: "error",
+                    error: {
+                      message: err.message,
+                      code: err.code || "INTERNAL_ERROR"
+                    }
+                  }),
+                  false
+                );
+              } catch (sendErr) {
+                console.error("Error sending error response:", sendErr);
+              }
+            }
+          }
+        }
+      },
+      // Обработчик закрытия соединения
+      close: (ws, code, message) => {
+        const userId = ws.userId;
+        if (userId && this.userConnections.has(userId)) {
+          this.userConnections.get(userId).delete(ws);
+          if (this.userConnections.get(userId).size === 0) {
+            this.userConnections.delete(userId);
+          }
+        }
+        if (ws.subscriptions && typeof ws.subscriptions.clear === "function") {
+          ws.subscriptions.clear();
+        }
+      }
+    });
+    this.listenSocket = null;
+  }
+  // Метод для запуска сервера
+  listen(port, callback) {
+    this.app.listen(port, (listenSocket) => {
+      if (listenSocket) {
+        this.listenSocket = listenSocket;
+        if (callback) callback(null, this.app);
+      } else {
+        if (callback) callback(new Error("Failed to listen"), null);
+      }
+    });
+    return this;
+  }
+  _trackUserConnection(userId, ws) {
+    if (!this.userConnections.has(userId)) {
+      this.userConnections.set(userId, /* @__PURE__ */ new Set());
+    }
+    this.userConnections.get(userId).add(ws);
+  }
+  registerModule(moduleName, handler) {
+    this.modules.set(moduleName, handler);
+  }
+  // Добавляем методы для регистрации RPC
+  registerRpcMethod(moduleName, methodName, handler, options = {}) {
+    const fullMethodName = `${moduleName}.${methodName}`;
+    if (!this.rpcMethods.has(moduleName)) {
+      this.rpcMethods.set(moduleName, /* @__PURE__ */ new Map());
+    }
+    this.rpcMethods.get(moduleName).set(methodName, {
+      handler,
+      options: {
+        requireAuth: options.requireAuth !== false,
+        // По умолчанию true
+        validateParams: options.validateParams || null,
+        rateLimit: options.rateLimit || null,
+        ...options
+      }
+    });
+    console.log(`RPC method registered: ${fullMethodName}`);
+    return this;
+  }
+  // Метод для регистрации группы RPC методов из модуля
+  registerRpcMethods(moduleName, methodsMap) {
+    for (const [methodName, config] of Object.entries(methodsMap)) {
+      const handler = typeof config === "function" ? config : config.handler;
+      const options = typeof config === "function" ? {} : config.options || {};
+      this.registerRpcMethod(moduleName, methodName, handler, options);
+    }
+    return this;
+  }
+  // Обработчик RPC вызовов
+  async _handleRpcCall(ws, message) {
+    const { module, method, params, id } = message;
+    if (!this.rpcMethods.has(module) || !this.rpcMethods.get(module).has(method)) {
+      this._sendRpcResponse(ws, id, null, {
+        code: -32601,
+        message: `Method ${module}.${method} not found`
+      });
+      return;
+    }
+    const { handler, options } = this.rpcMethods.get(module).get(method);
+    if (options.requireAuth && !ws.userId) {
+      this._sendRpcResponse(ws, id, null, {
+        code: -32e3,
+        message: "Authentication required"
+      });
+      return;
+    }
+    if (options.validateParams && !options.validateParams(params)) {
+      this._sendRpcResponse(ws, id, null, {
+        code: -32602,
+        message: "Invalid params"
+      });
+      return;
+    }
+    try {
+      const context = {
+        userId: ws.userId,
+        ws,
+        sendResponse: (result2) => this._sendRpcResponse(ws, id, result2),
+        sendError: (error) => this._sendRpcResponse(ws, id, null, error)
+      };
+      const result = await handler.call(context, params, context);
+      if (!context.responseSent) {
+        this._sendRpcResponse(ws, id, result);
+      }
+    } catch (error) {
+      console.error(`Error executing RPC method ${module}.${method}:`, error);
+      this._sendRpcResponse(ws, id, null, {
+        code: -32603,
+        message: error.message || "Internal error"
+      });
+    }
+  }
+  // Отправка ответа на RPC запрос
+  _sendRpcResponse(ws, id, result, error = null) {
+    if (ws.context?.responseSent) return;
+    if (ws.context) ws.context.responseSent = true;
+    const response = {
+      type: "rpc_response",
+      id
+    };
+    if (error) {
+      response.error = {
+        code: error.code || -32603,
+        message: error.message || "Internal error",
+        data: error.data
+      };
+    } else {
+      response.result = result;
+    }
+    try {
+      ws.send(JSON.stringify(response), false);
+    } catch (err) {
+      console.error("Error sending RPC response:", err);
+    }
+  }
+  sendToUserInModule(moduleName, userId, data) {
+    const userIdStr = userId.toString();
+    const sockets = this.userConnections.get(userIdStr);
+    if (!sockets) {
+      console.log(`No sockets found for user ${userIdStr}`);
+      return false;
+    }
+    let sent = false;
+    const message = JSON.stringify(data);
+    for (const ws of sockets) {
+      if (ws.subscriptions.has(moduleName)) {
+        try {
+          const ok = ws.send(message, false);
+          if (!ok) {
+            console.warn("WebSocket backpressure exceeded for user:", userIdStr);
+          } else {
+            sent = true;
+          }
+        } catch (err) {
+          console.warn("Failed to send message to user:", userIdStr, err);
+        }
+      }
+    }
+    return sent;
+  }
+  broadcastToModule(moduleName, data) {
+    const message = JSON.stringify(data);
+    let failedSends = 0;
+    for (const sockets of this.userConnections.values()) {
+      for (const ws of sockets) {
+        if (ws.subscriptions.has(moduleName)) {
+          try {
+            const ok = ws.send(message, false);
+            if (!ok) {
+              failedSends++;
+            }
+          } catch (err) {
+            failedSends++;
+            console.warn("Failed to broadcast message:", err);
+          }
+        }
+      }
+    }
+    if (failedSends > 0) {
+      console.warn(`Failed to send broadcast to ${failedSends} connections due to backpressure or closed sockets`);
+    }
+    return true;
+  }
+  broadcastToModuleWithFilter(moduleName, filterFn, data) {
+    const message = JSON.stringify(data);
+    let failedSends = 0;
+    for (const sockets of this.userConnections.values()) {
+      for (const ws of sockets) {
+        if (!ws.subscriptions.has(moduleName)) continue;
+        if (!filterFn(ws)) continue;
+        try {
+          const ok = ws.send(message, false);
+          if (!ok) {
+            failedSends++;
+          }
+        } catch (err) {
+          failedSends++;
+          console.warn("Failed to send filtered broadcast:", err);
+        }
+      }
+    }
+    if (failedSends > 0) {
+      console.warn(`Failed to send filtered broadcast to ${failedSends} connections due to backpressure or closed sockets`);
+    }
+    return true;
+  }
+  getServer() {
+    return this.app;
+  }
+}
 const initGlobalsPolicies = function initializeDefaultPolicies(abacAccessControl) {
   abacAccessControl.registerGlobalPolicy("AdminModeratorAccessPolicy", async (context) => {
     const { user, req } = context;

package/dist/{globals.verifier-D68mHEBl.cjs → globals.verifier-C0zj_LLo.cjs}

@@ -78,7 +78,14 @@ class Validator {
   boolean(message) {
     this.rules.push({
       type: "boolean",
-      check: (value) => typeof value === "boolean",
+      check: (value) => {
+        if (typeof value === "boolean") return true;
+        if (typeof value === "string") {
+          const lowered = value.toLowerCase();
+          return lowered === "true" || lowered === "false";
+        }
+        return false;
+      },
       message
     });
     return this;

package/dist/{globals.verifier-CWFz5Gh2.js → globals.verifier-DFqKQ7hK.js}

@@ -77,7 +77,14 @@ class Validator {
   boolean(message) {
     this.rules.push({
       type: "boolean",
-      check: (value) => typeof value === "boolean",
+      check: (value) => {
+        if (typeof value === "boolean") return true;
+        if (typeof value === "string") {
+          const lowered = value.toLowerCase();
+          return lowered === "true" || lowered === "false";
+        }
+        return false;
+      },
       message
     });
     return this;

package/dist/inventory.server.cjs

@@ -6,8 +6,8 @@ const globals_abac = require("./globals.abac-CPXLas7N.cjs");
 const globals_logger = require("./globals.logger-CZMgIMlM.cjs");
 const globals_observer = require("./globals.observer-CV2wCzzh.cjs");
 const queryProcessor = require("./queryProcessor-B_X680wC.cjs");
-const globals_verifier = require("./globals.verifier-D68mHEBl.cjs");
-const crud = require("./crud-B-kQw3Z5.cjs");
+const globals_verifier = require("./globals.verifier-C0zj_LLo.cjs");
+const crud = require("./crud-JN_LFj01.cjs");
 const abac = require("./abac-6LjoG9u-.cjs");
 const StockAdjustmentModel = (db) => {
   const StockAdjustmentSchema = new db.mongoose.Schema({

package/dist/inventory.server.js

@@ -4,8 +4,8 @@ import { g as globalsabac } from "./globals.abac-DNdtSYop.js";
 import { C as Cache, L as Logger } from "./globals.logger-Bf6rRU7j.js";
 import { O as Observer } from "./globals.observer-CDqUjVU5.js";
 import { q as queryProcessorGlobals } from "./queryProcessor-CVcLPEnv.js";
-import { a as Validator, V as Verifier } from "./globals.verifier-CWFz5Gh2.js";
-import { C as CRUD } from "./crud-Cwx5VlSm.js";
+import { a as Validator, V as Verifier } from "./globals.verifier-DFqKQ7hK.js";
+import { C as CRUD } from "./crud-sE7GLPbj.js";
 import { A as ABAC } from "./abac-Cf_9lCSh.js";
 const StockAdjustmentModel = (db) => {
   const StockAdjustmentSchema = new db.mongoose.Schema({