crazy-odds-bet-shared 1.0.0

package/README.md

@@ -0,0 +1,182 @@
+# Shared
+
+Shared MongoDB models and database utilities for the odds project.
+
+## Features
+
+- **MongoDB Connection Manager**: Easy connect/disconnect functionality
+- **Mongoose Models**: Pre-built models with TypeScript support
+  - Bookmakers
+  - Sports
+  - Competitions
+  - Teams
+  - Fixtures
+- **Common Schema Utilities**: UUID-based IDs, timestamps, external references
+
+## Installation
+
+```bash
+cd shared
+npm install
+npm run build
+```
+
+## Configuration
+
+Copy `.env.example` to `.env` and configure your MongoDB connection. The shared
+package loads its own `.env` file and overrides other envs, so the API and
+collector both use these settings.
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` (Atlas SRV example):
+
+```env
+MONGODB_URI=mongodb+srv://username:password@cluster0.gmu25o7.mongodb.net/?retryWrites=true&w=majority
+DB_NAME=odds_dev
+```
+
+Local MongoDB example:
+
+```env
+MONGODB_URI=mongodb://127.0.0.1:27017
+DB_NAME=odds_project
+```
+
+DNS note (Windows): If SRV resolution fails, verify your cluster host resolves:
+
+```powershell
+nslookup _mongodb._tcp.<your-cluster>.mongodb.net
+nslookup <your-cluster>.mongodb.net
+```
+
+## Usage
+
+### Connecting to MongoDB
+
+```typescript
+import { MongoDB } from "@odds-project/shared/db";
+
+// Connect using environment variables (from shared/.env)
+await MongoDB.connect();
+
+// Or provide connection details explicitly
+await MongoDB.connect("mongodb://localhost:27017", "odds_db");
+
+// Check connection
+if (MongoDB.isConnected()) {
+  console.log("Connected!");
+}
+
+// Disconnect
+await MongoDB.disconnect();
+```
+
+### Using Models
+
+```typescript
+import {
+  Bookmaker,
+  Fixture,
+  FixtureStatus,
+  Sport,
+} from "@odds-project/shared/models";
+
+// Create a bookmaker
+const bookmaker = await Bookmaker.create({
+  name: "Bet365",
+  slug: "bet365",
+  country: "UK",
+  website: "https://www.bet365.com",
+  isActive: true,
+  metadata: { rating: 4.5 },
+});
+
+// Create a sport
+const sport = await Sport.create({
+  name: "Football",
+  slug: "football",
+  displayName: "Football",
+  isActive: true,
+  externalRefs: [
+    {
+      id: "ext-123",
+      name: "Provider A",
+      slug: "provider-a",
+      isActive: true,
+      metadata: {},
+    },
+  ],
+});
+
+// Create a fixture
+const fixture = await Fixture.create({
+  sportId: sport._id,
+  competitionId: "comp-uuid",
+  homeTeamId: "team1-uuid",
+  awayTeamId: "team2-uuid",
+  scheduledAt: new Date("2025-12-25T15:00:00Z"),
+  status: FixtureStatus.SCHEDULED,
+  externalRefs: [],
+  metadata: { venue: "Stadium Name" },
+});
+
+// Query fixtures
+const upcomingFixtures = await Fixture.find({
+  status: FixtureStatus.SCHEDULED,
+  scheduledAt: { $gte: new Date() },
+}).sort({ scheduledAt: 1 });
+```
+
+## Models
+
+### Bookmaker
+
+- name, slug, country, website
+- isActive flag
+- metadata object
+
+### Sport
+
+- name, slug, displayName
+- isActive flag
+- externalRefs array
+
+### Competition
+
+- sportId (ref to Sport)
+- name, slug, country, season
+- isActive flag
+- externalRefs array
+
+### Team
+
+- sportId (ref to Sport)
+- name, slug
+- isActive flag
+- externalRefs array
+
+### Fixture
+
+- sportId, competitionId, homeTeamId, awayTeamId (refs)
+- scheduledAt (Date)
+- status (scheduled | live | finished | postponed | cancelled)
+- externalRefs array
+- metadata object
+
+## Common Features
+
+All models include:
+
+- `_id`: UUID string (generated automatically)
+- `createdAt`: timestamp
+- `updatedAt`: timestamp
+- No version key (`__v`)
+
+## Scripts
+
+- `npm run build`: Compile TypeScript to JavaScript
+- `npm run dev`: Watch mode for development
+- `npm run clean`: Remove dist folder

package/db/index.js

@@ -0,0 +1,3 @@
+const { MongoDB } = require('./mongodb');
+
+module.exports = { MongoDB };

package/db/mongodb.js

@@ -0,0 +1,98 @@
+const mongoose = require('mongoose');
+const dotenv = require('dotenv');
+const path = require('path');
+const fs = require('fs');
+const { logger } = require('../utils/logging/logger');
+
+// Load environment variables from shared/.env as a fallback without overriding existing env
+const sharedEnvPath = path.resolve(__dirname, '../../.env');
+if (fs.existsSync(sharedEnvPath)) {
+  dotenv.config({ path: sharedEnvPath, override: false });
+}
+
+// Suppress duplicate schema index warnings - these are benign
+const originalEmitWarning = process.emitWarning;
+process.emitWarning = function (warning, ...args) {
+  if (typeof warning === 'string' && warning.includes('Duplicate schema index')) {
+    return;
+  }
+  if (warning?.message?.includes?.('Duplicate schema index')) {
+    return;
+  }
+  return originalEmitWarning.apply(process, [warning, ...args]);
+};
+
+/**
+ * MongoDB connection manager for collector and api apps
+ */
+class MongoDB {
+  static connection = null;
+
+  /**
+   * Connect to MongoDB using environment variables or provided connection string
+   * @param connectionString - Optional MongoDB connection URI (overrides env)
+   * @param dbName - Optional database name (overrides env)
+   * @param options - Additional mongoose connection options
+   */
+  static async connect(
+    connectionString,
+    dbName,
+    options = {}
+  ) {
+    try {
+      const uri = connectionString || process.env.MONGODB_URI;
+      const database = dbName || process.env.DB_NAME;
+
+      if (!uri) {
+        throw new Error('MongoDB URI not provided. Set MONGODB_URI in .env or pass as parameter.');
+      }
+
+      // Construct full connection string with database name
+      let fullUri = uri;
+      if (database) {
+        // If URI doesn't already specify a database, append it
+        if (!uri.includes('mongodb.net/') || uri.endsWith('mongodb.net/')) {
+          fullUri = uri.replace(/\/$/, '') + '/' + database;
+        } else if (uri.includes('?')) {
+          fullUri = uri.replace('?', database + '?');
+        }
+      }
+
+      this.connection = await mongoose.connect(fullUri, options);
+      logger.info(`✓ Connected to MongoDB${database ? ` (database: ${database})` : ''}`);
+    } catch (error) {
+      logger.error('✗ Failed to connect to MongoDB:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Disconnect from MongoDB
+   */
+  static async disconnect() {
+    if (this.connection) {
+      await mongoose.disconnect();
+      this.connection = null;
+      logger.info('✓ Disconnected from MongoDB');
+    }
+  }
+
+  /**
+   * Get the mongoose connection instance
+   */
+  static getConnection() {
+    if (!this.connection) {
+      throw new Error('Database not initialized. Call connect() first.');
+    }
+    return this.connection;
+  }
+
+  /**
+   * Check if connected to MongoDB
+   */
+  static isConnected() {
+    return mongoose.connection.readyState === 1;
+  }
+}
+
+module.exports = { MongoDB };

package/index.js

@@ -0,0 +1,9 @@
+const db = require('./db');
+const models = require('./models');
+const utils = require('./utils');
+
+module.exports = {
+  ...db,
+  ...models,
+  ...utils
+};

package/models/base.js

@@ -0,0 +1,121 @@
+const { Schema } = require('mongoose');
+const { v4: uuidv4 } = require('uuid');
+
+/**
+ * External reference schema
+ */
+const externalRefSchema = new Schema(
+  {
+    id: { type: String, required: true },
+    name: { type: String, required: true },
+    slug: { type: String, required: false, unique: false, sparse: true },
+    isActive: { type: Boolean, default: true },
+    metadata: { type: Schema.Types.Mixed, default: {} }
+  },
+  { _id: false }
+);
+
+/**
+ * Base schema options for all models
+ */
+const baseSchemaOptions = {
+  timestamps: true,
+  versionKey: false,
+  _id: false,
+  minimize: false // Keep empty objects (e.g., specifiers) persisted across all schemas
+};
+
+/**
+ * Creates base schema fields with custom _id using uuidv4
+ */
+const createBaseSchema = () => ({
+  _id: {
+    type: String,
+    default: () => uuidv4(),
+    alias: 'id'
+  }
+});
+
+/**
+ * Generates a slug from a string
+ */
+const generateSlug = (text) => {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/\s+/g, '-')
+    .replace(/[^\w-]/g, '');
+};
+
+/**
+ * Adds auto-slug generation pre-save hook to a schema
+ * @param schema The mongoose schema to add the hook to
+ * @param sourceField The field to generate the slug from (defaults to 'name')
+ */
+const addAutoSlugHook = (schema, sourceField = 'name') => {
+  schema.pre('save', function (next) {
+    if (this.isModified(sourceField) || !this.get('slug')) {
+      const sourceValue = this.get(sourceField);
+      if (sourceValue) {
+        this.set('slug', generateSlug(sourceValue));
+      }
+    }
+    next();
+  });
+};
+
+/**
+ * Adds slug generation for external reference arrays on save
+ * @param schema The mongoose schema to add the hook to
+ * @param refPath The path to the external refs array (defaults to 'externalRefs')
+ * @param sourceField The field to generate the slug from inside each ref (defaults to 'name')
+ */
+const addExternalRefsSlugHook = (
+  schema,
+  refPath = 'externalRefs',
+  sourceField = 'name'
+) => {
+  schema.pre('save', function (next) {
+    const refs = this.get(refPath);
+    if (Array.isArray(refs)) {
+      const updated = refs.map((ref) => {
+        if (ref && !ref.slug && ref[sourceField]) {
+          return { ...ref, slug: generateSlug(ref[sourceField]) };
+        }
+        return ref;
+      });
+      this.set(refPath, updated);
+    } else if (refs && typeof refs === 'object') {
+      if (refs instanceof Map) {
+        const updated = new Map(refs);
+        updated.forEach((ref, key) => {
+          if (ref && !ref.slug && ref[sourceField]) {
+            updated.set(key, { ...ref, slug: generateSlug(ref[sourceField]) });
+          }
+        });
+        this.set(refPath, updated);
+      } else {
+        const updated = {};
+        for (const key of Object.keys(refs)) {
+          const ref = refs[key];
+          if (ref && !ref.slug && ref[sourceField]) {
+            updated[key] = { ...ref, slug: generateSlug(ref[sourceField]) };
+          } else {
+            updated[key] = ref;
+          }
+        }
+        this.set(refPath, updated);
+      }
+    }
+    next();
+  });
+};
+
+module.exports = {
+  externalRefSchema,
+  baseSchemaOptions,
+  createBaseSchema,
+  generateSlug,
+  addAutoSlugHook,
+  addExternalRefsSlugHook
+};

package/models/betTracker.js

@@ -0,0 +1,32 @@
+const { Schema, model } = require('mongoose');
+const { createBaseSchema, baseSchemaOptions } = require('./base');
+
+const betTrackerSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    groupId: { type: String },
+    bookmakerId: { type: String, required: true, ref: 'Bookmaker' },
+    bookmakerName: { type: String },
+    fixtureId: { type: String, required: true, ref: 'Fixture' },
+    fixtureName: { type: String },
+    fixtureDate: { type: Date },
+    sportName: { type: String },
+    competitionName: { type: String },
+    marketName: { type: String },
+    odd: { type: Number, required: true },
+    oddName: { type: String },
+    oddStatus: { type: String, default: 'pending' },
+    stake: { type: Number, required: true },
+    type: { type: String, default: 'arbitrage' },
+    notes: { type: String }
+  },
+  baseSchemaOptions
+);
+
+betTrackerSchema.index({ fixtureId: 1 });
+betTrackerSchema.index({ groupId: 1 });
+betTrackerSchema.index({ bookmakerId: 1 });
+
+const BetTracker = model('BetTracker', betTrackerSchema);
+
+module.exports = { BetTracker };

package/models/bookmaker.js

@@ -0,0 +1,52 @@
+const { Schema, model } = require('mongoose');
+const { createBaseSchema, baseSchemaOptions, addAutoSlugHook } = require('./base');
+
+const bookmakerSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    name: { type: String, required: true },
+    slug: { type: String, required: false, unique: true, sparse: true },
+    country: { type: String, required: false, sparse: true },
+    website: { type: String, required: false, sparse: true },
+    isActive: { type: Boolean, default: true },
+    metadata: { type: Schema.Types.Mixed, default: {} }
+  },
+  baseSchemaOptions
+);
+
+// Indexes
+bookmakerSchema.index({ isActive: 1 });
+bookmakerSchema.index({ name: 'text' });
+
+// Add auto-slug generation from name field
+addAutoSlugHook(bookmakerSchema, 'name');
+
+// Static methods
+bookmakerSchema.static('findBySlug', function (slug) {
+  return this.findOne({ slug });
+});
+
+bookmakerSchema.static('getActive', function () {
+  return this.find({ isActive: true }).sort({ name: 1 });
+});
+
+bookmakerSchema.static('searchByName', function (query) {
+  return this.find({
+    name: { $regex: query, $options: 'i' }
+  }).sort({ name: 1 });
+});
+
+// Instance methods
+bookmakerSchema.method('activate', async function () {
+  this.isActive = true;
+  return this.save();
+});
+
+bookmakerSchema.method('deactivate', async function () {
+  this.isActive = false;
+  return this.save();
+});
+
+const Bookmaker = model('Bookmaker', bookmakerSchema);
+
+module.exports = { Bookmaker };

package/models/competition.js

@@ -0,0 +1,163 @@
+const { Schema, model } = require('mongoose');
+const {
+  createBaseSchema,
+  baseSchemaOptions,
+  addAutoSlugHook,
+  addExternalRefsSlugHook
+} = require('./base');
+
+/**
+ * Competition schema
+ */
+const competitionSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    sportId: { type: String, required: true, ref: 'Sport' },
+    name: { type: String, required: true },
+    slug: { type: String, required: true },
+    country: { type: String, required: false, sparse: true },
+    season: { type: String, required: false, sparse: true },
+    isActive: { type: Boolean, default: true },
+    externalRefs: { type: Schema.Types.Mixed, default: {} }
+  },
+  {
+    ...baseSchemaOptions,
+    autoIndex: process.env.NODE_ENV !== 'production'
+  }
+);
+
+// Indexes
+competitionSchema.index({ slug: 1, season: 1 }, { unique: true, sparse: true });
+competitionSchema.index({ sportId: 1 });
+competitionSchema.index({ isActive: 1 });
+competitionSchema.index({ name: 'text' });
+
+// Clear any duplicate indexes
+if (competitionSchema.clearIndexes) {
+  competitionSchema.clearIndexes();
+}
+
+// Virtuals
+competitionSchema.virtual('sport', {
+  ref: 'Sport',
+  localField: 'sportId',
+  foreignField: '_id',
+  justOne: true
+});
+
+// Migration hook: convert array externalRefs to object
+competitionSchema.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(competitionSchema, 'name');
+
+// Add auto-slug generation for external refs
+addExternalRefsSlugHook(competitionSchema, 'externalRefs');
+
+// Static methods
+competitionSchema.static('findBySlug', function (slug, sport, season) {
+  const query = { slug };
+  if (sport) query.sportId = sport;
+  if (season) query.season = season;
+  return this.findOne(query);
+});
+
+competitionSchema.static('getActive', function () {
+  return this.find({ isActive: true }).sort({ name: 1 });
+});
+
+competitionSchema.static('findByExternalRef', function (bookmakerSlug, sportId, externalId) {
+  const query = {};
+  query[`externalRefs.${bookmakerSlug}.id`] = externalId;
+  query['sportId'] = sportId;
+  return this.findOne(query);
+});
+
+competitionSchema.static('findBySport', function (sportId) {
+  return this.find({ sportId, isActive: true }).sort({ name: 1 });
+});
+
+competitionSchema.static('searchByName', function (query) {
+  return this.find({
+    name: { $regex: query, $options: 'i' }
+  }).sort({ name: 1 });
+});
+
+// Instance methods
+competitionSchema.method('activate', async function () {
+  this.isActive = true;
+  return this.save();
+});
+
+competitionSchema.method('deactivate', async function () {
+  this.isActive = false;
+  return this.save();
+});
+
+competitionSchema.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();
+});
+
+competitionSchema.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();
+});
+
+competitionSchema.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;
+});
+
+competitionSchema.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 Competition = model('Competition', competitionSchema);
+
+module.exports = { Competition };