crazy-odds-bet-shared 1.0.0

package/models/sport.js

@@ -0,0 +1,145 @@
+const { Schema, model } = require('mongoose');
+const {
+  createBaseSchema,
+  baseSchemaOptions,
+  addAutoSlugHook,
+  addExternalRefsSlugHook
+} = require('./base');
+
+/**
+ * Sport schema
+ */
+const sportSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    name: { type: String, required: true },
+    slug: { type: String, required: true },
+    displayName: { type: String, required: true },
+    isActive: { type: Boolean, default: true },
+    externalRefs: { type: Schema.Types.Mixed, default: {} }
+  },
+  {
+    ...baseSchemaOptions,
+    autoIndex: process.env.NODE_ENV !== 'production'
+  }
+);
+
+// Indexes
+sportSchema.index({ slug: 1 }, { unique: true, sparse: true });
+sportSchema.index({ isActive: 1 });
+sportSchema.index({ name: 'text', displayName: 'text' });
+
+// Clear any duplicate indexes
+if (sportSchema.clearIndexes) {
+  sportSchema.clearIndexes();
+}
+
+// Migration hook: convert array externalRefs to object
+sportSchema.pre('save', function (next) {
+  if (this.externalRefs && Array.isArray(this.externalRefs)) {
+    // Migrate from array to object format
+    const converted = {};
+    this.externalRefs.forEach((ref) => {
+      if (ref && ref.bookmaker) {
+        // If array has bookmaker property, use it as key
+        const { bookmaker, ...refData } = ref;
+        converted[bookmaker] = refData;
+      } else if (ref && ref.slug) {
+        // Fallback to slug as key
+        converted[ref.slug] = ref;
+      }
+    });
+    this.externalRefs = converted;
+  }
+  next();
+});
+
+// Add auto-slug generation from name field
+addAutoSlugHook(sportSchema, 'name');
+
+// Add auto-slug generation for external refs
+addExternalRefsSlugHook(sportSchema, 'externalRefs');
+
+// Static methods
+sportSchema.static('findBySlug', function (slug) {
+  return this.findOne({ slug });
+});
+
+sportSchema.static('getActive', function () {
+  return this.find({ isActive: true }).sort({ name: 1 });
+});
+
+sportSchema.static('findByExternalRefId', function (refId) {
+  return this.find({ 'externalRefs.id': refId });
+});
+
+sportSchema.static('searchByName', function (query) {
+  return this.find({
+    $or: [
+      { name: { $regex: query, $options: 'i' } },
+      { displayName: { $regex: query, $options: 'i' } }
+    ]
+  }).sort({ name: 1 });
+});
+
+// Instance methods
+sportSchema.method('activate', async function () {
+  this.isActive = true;
+  return this.save();
+});
+
+sportSchema.method('deactivate', async function () {
+  this.isActive = false;
+  return this.save();
+});
+
+sportSchema.method('addExternalRef', async function (key, ref) {
+  if (!this.externalRefs || typeof this.externalRefs !== 'object') {
+    this.externalRefs = {};
+  }
+  const refs = this.externalRefs;
+  refs[key] = ref;
+  this.markModified('externalRefs');
+  return this.save();
+});
+
+sportSchema.method('removeExternalRef', async function (key) {
+  if (this.externalRefs && typeof this.externalRefs === 'object') {
+    const refs = this.externalRefs;
+    delete refs[key];
+    this.markModified('externalRefs');
+  }
+  return this.save();
+});
+
+sportSchema.method('activateExternalRef', async function (key) {
+  if (this.externalRefs && typeof this.externalRefs === 'object') {
+    const refs = this.externalRefs;
+    const ref = refs[key];
+    if (ref) {
+      ref.isActive = true;
+      refs[key] = ref;
+      this.markModified('externalRefs');
+      return this.save();
+    }
+  }
+  return this;
+});
+
+sportSchema.method('deactivateExternalRef', async function (key) {
+  if (this.externalRefs && typeof this.externalRefs === 'object') {
+    const refs = this.externalRefs;
+    const ref = refs[key];
+    if (ref) {
+      ref.isActive = false;
+      refs[key] = ref;
+      this.markModified('externalRefs');
+      return this.save();
+    }
+  }
+  return this;
+});
+
+const Sport = model('Sport', sportSchema);
+
+module.exports = { Sport };

package/models/team.js

@@ -0,0 +1,133 @@
+const { Schema, model } = require('mongoose');
+const {
+  createBaseSchema,
+  baseSchemaOptions,
+  addAutoSlugHook,
+  addExternalRefsSlugHook
+} = require('./base');
+
+/**
+ * Team schema
+ */
+const teamSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    sportId: { type: String, required: true, ref: 'Sport' },
+    resourceId: { type: String },
+    name: { type: String, required: true },
+    slug: { type: String, unique: true, sparse: true },
+    isActive: { type: Boolean, default: true },
+    metadata: { type: Schema.Types.Mixed, default: {} },
+    externalRefs: { type: Schema.Types.Mixed, default: {} }
+  },
+  baseSchemaOptions
+);
+
+// Indexes
+teamSchema.index({ slug: 1 });
+teamSchema.index({ sportId: 1 });
+teamSchema.index({ isActive: 1 });
+teamSchema.index({ name: 'text' });
+
+// Virtuals
+teamSchema.virtual('sport', {
+  ref: 'Sport',
+  localField: 'sportId',
+  foreignField: '_id',
+  justOne: true
+});
+
+// Add auto-slug generation from name field
+addAutoSlugHook(teamSchema, 'name');
+
+// Static methods
+teamSchema.static('findBySlug', function (slug) {
+  return this.findOne({ slug });
+});
+
+teamSchema.static('getActive', function () {
+  return this.find({ isActive: true }).sort({ name: 1 });
+});
+
+teamSchema.static('findByExternalRef', function (bookmakerSlug, sportId, externalId) {
+  const query = {};
+  query[`externalRefs.${bookmakerSlug}.id`] = externalId;
+  query['sportId'] = sportId;
+  return this.findOne(query);
+});
+
+teamSchema.static('findByExternalRefName', function (bookmakerSlug, sportId, externalName) {
+  const query = {};
+  query[`externalRefs.${bookmakerSlug}.name`] = externalName;
+  query['sportId'] = sportId;
+  return this.findOne(query);
+});
+
+teamSchema.static('findBySport', function (sportId) {
+  return this.find({ sportId, isActive: true }).sort({ name: 1 });
+});
+
+teamSchema.static('searchByName', function (query) {
+  return this.find({
+    name: { $regex: query, $options: 'i' }
+  }).sort({ name: 1 });
+});
+
+// Instance methods
+teamSchema.method('activate', async function () {
+  this.isActive = true;
+  return this.save();
+});
+
+teamSchema.method('deactivate', async function () {
+  this.isActive = false;
+  return this.save();
+});
+
+teamSchema.method('addExternalRef', async function (bookmakerSlug, externalId, data) {
+  const ref = {
+    id: externalId,
+    name: data.name,
+    slug: data.slug,
+    isActive: data.isActive !== undefined ? data.isActive : true,
+    metadata: data.metadata || {}
+  };
+  this.externalRefs[bookmakerSlug] = ref;
+  this.markModified('externalRefs');
+  return this.save();
+});
+
+teamSchema.method('getExternalRef', function (bookmakerSlug) {
+  return this.externalRefs?.[bookmakerSlug] || null;
+});
+
+teamSchema.method('removeExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    delete this.externalRefs[bookmakerSlug];
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+teamSchema.method('activateExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    this.externalRefs[bookmakerSlug].isActive = true;
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+teamSchema.method('deactivateExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    this.externalRefs[bookmakerSlug].isActive = false;
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+const Team = model('Team', teamSchema);
+
+module.exports = { Team };

package/models/user.js

@@ -0,0 +1,62 @@
+const { Schema, model } = require('mongoose');
+const { createBaseSchema, baseSchemaOptions } = require('./base');
+
+/**
+ * User schema
+ */
+const userSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    email: { type: String, required: true, unique: true, lowercase: true, trim: true },
+    password: { type: String, required: true },
+    name: { type: String, required: true },
+    role: { type: String, enum: ['admin', 'user'], default: 'user' },
+    isActive: { type: Boolean, default: true }
+  },
+  baseSchemaOptions
+);
+
+// Indexes
+userSchema.index({ isActive: 1 });
+userSchema.index({ role: 1 });
+
+// Static methods
+userSchema.static('findByEmail', function (email) {
+  return this.findOne({ email: email.toLowerCase() });
+});
+
+userSchema.static('getActive', function () {
+  return this.find({ isActive: true }).select('-password');
+});
+
+userSchema.static('findAdmins', function () {
+  return this.find({ role: 'admin', isActive: true }).select('-password');
+});
+
+// Instance methods
+userSchema.method('activate', async function () {
+  this.isActive = true;
+  return this.save();
+});
+
+userSchema.method('deactivate', async function () {
+  this.isActive = false;
+  return this.save();
+});
+
+userSchema.method('comparePassword', async function (password) {
+  // For now, simple comparison. In production, use bcrypt
+  return this.password === password;
+});
+
+// Middleware to exclude password from toJSON
+userSchema.set('toJSON', {
+  transform: (doc, ret) => {
+    delete ret.password;
+    return ret;
+  }
+});
+
+const User = model('User', userSchema);
+
+module.exports = { User };

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "crazy-odds-bet-shared",
+  "version": "1.0.0",
+  "description": "Shared MongoDB models and utilities for odds project",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "db",
+    "models",
+    "utils"
+  ],
+  "scripts": {
+    "lint": "echo \"Lint not configured yet\"",
+    "test": "echo \"No tests yet\""
+  },
+  "keywords": [
+    "mongodb",
+    "models",
+    "utilities",
+    "shared"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "dotenv": "^16.3.1",
+    "mongoose": "^8.0.0",
+    "uuid": "^9.0.1"
+  }
+}

package/utils/index.js

@@ -0,0 +1,4 @@
+const { logger } = require('./logging/logger.js');
+const { getLoggerConfig } = require('./logging/config.js');
+
+module.exports = { logger, getLoggerConfig };

package/utils/logging/config.js

@@ -0,0 +1,41 @@
+/**
+ * Unified logging configuration
+ * Simple JSON logging for production, pretty-printed in development
+ */
+
+const getLoggerConfig = (nodeEnv = 'development') => {
+  const isDev = nodeEnv !== 'production';
+  const logLevel = process.env.LOG_LEVEL || (isDev ? 'debug' : 'info');
+
+  return {
+    isDev,
+    logLevel,
+    colorize: isDev,
+    serializers: {
+      req: (req) => ({
+        method: req.method,
+        url: req.url,
+        headers: {
+          host: req.headers?.host,
+          'content-type': req.headers?.['content-type'],
+          'user-agent': req.headers?.['user-agent']
+        },
+        remoteAddress: req.ip,
+        remotePort: req.socket?.remotePort
+      }),
+      res: (res) => ({
+        statusCode: res.statusCode,
+        responseTime: res.responseTime,
+        headers: res.getHeaders?.()
+      }),
+      error: (err) => ({
+        message: err.message,
+        stack: err.stack,
+        code: err.code,
+        statusCode: err.statusCode
+      })
+    }
+  };
+};
+
+module.exports = { getLoggerConfig };

package/utils/logging/logger.js

@@ -0,0 +1,55 @@
+const { getLoggerConfig } = require('./config');
+
+const nodeEnv = process.env.NODE_ENV || 'development';
+const config = getLoggerConfig(nodeEnv);
+
+// Simple logger without external dependencies
+const logger = {
+  debug: (message, data) => logMessage('DEBUG', message, data),
+  info: (message, data) => logMessage('INFO', message, data),
+  warn: (message, data) => logMessage('WARN', message, data),
+  error: (message, data) => logMessage('ERROR', message, data),
+  fatal: (message, data) => logMessage('FATAL', message, data)
+};
+
+function logMessage(level, message, data) {
+  // Check if log level should be displayed
+  const logLevels = { debug: 0, info: 1, warn: 2, error: 3, fatal: 4 };
+  const currentLevel = logLevels[config.logLevel] || 1;
+  const messageLevel = logLevels[level.toLowerCase()] || 0;
+
+  if (messageLevel < currentLevel) return;
+
+  const timestamp = new Date().toISOString();
+  const logEntry = {
+    timestamp,
+    level,
+    message,
+    ...(data && typeof data === 'object' ? data : {})
+  };
+
+  if (config.isDev) {
+    // Pretty print for development
+    const color = getColorCode(level);
+    console.log(
+      `${color}[${timestamp}] ${level}${'\x1b[0m'} ${message}`,
+      data && Object.keys(data).length > 0 ? JSON.stringify(data, null, 2) : ''
+    );
+  } else {
+    // JSON output for production
+    console.log(JSON.stringify(logEntry));
+  }
+}
+
+function getColorCode(level) {
+  const colors = {
+    DEBUG: '\x1b[36m', // cyan
+    INFO: '\x1b[32m',  // green
+    WARN: '\x1b[33m',  // yellow
+    ERROR: '\x1b[31m', // red
+    FATAL: '\x1b[35m'  // magenta
+  };
+  return colors[level] || '';
+}
+
+module.exports = { logger };