crazy-odds-bet-shared 1.0.0

package/models/fixture.js

@@ -0,0 +1,218 @@
+const { Schema, model } = require('mongoose');
+const {
+  createBaseSchema,
+  baseSchemaOptions,
+  addExternalRefsSlugHook
+} = require('./base');
+
+/**
+ * Fixture status enum
+ */
+const FixtureStatus = {
+  SCHEDULED: 'scheduled',
+  LIVE: 'live',
+  FINISHED: 'finished',
+  POSTPONED: 'postponed',
+  CANCELLED: 'cancelled'
+};
+
+/**
+ * Fixture schema
+ */
+const fixtureSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    sportId: { type: String, required: true, ref: 'Sport' },
+    competitionId: { type: String, required: true, ref: 'Competition' },
+    resourceId: { type: String },
+    homeTeamId: { type: String, required: true, ref: 'Team' },
+    awayTeamId: { type: String, required: true, ref: 'Team' },
+    name: { type: String, required: true },
+    slug: { type: String, unique: true, sparse: true },
+    scheduledAt: { type: Date, required: true },
+    status: {
+      type: String,
+      enum: Object.values(FixtureStatus),
+      default: FixtureStatus.SCHEDULED
+    },
+    externalRefs: { type: Schema.Types.Mixed, default: {} },
+    metadata: { type: Schema.Types.Mixed, default: {} }
+  },
+  baseSchemaOptions
+);
+
+// Indexes
+fixtureSchema.index({ sportId: 1 });
+fixtureSchema.index({ competitionId: 1 });
+fixtureSchema.index({ homeTeamId: 1 });
+fixtureSchema.index({ awayTeamId: 1 });
+fixtureSchema.index({ scheduledAt: 1 });
+fixtureSchema.index({ status: 1 });
+fixtureSchema.index({ scheduledAt: 1, status: 1 });
+
+// Add auto-slug generation for external refs
+addExternalRefsSlugHook(fixtureSchema, 'externalRefs');
+
+// Virtuals
+fixtureSchema.virtual('sport', {
+  ref: 'Sport',
+  localField: 'sportId',
+  foreignField: '_id',
+  justOne: true
+});
+
+fixtureSchema.virtual('competition', {
+  ref: 'Competition',
+  localField: 'competitionId',
+  foreignField: '_id',
+  justOne: true
+});
+
+fixtureSchema.virtual('homeTeam', {
+  ref: 'Team',
+  localField: 'homeTeamId',
+  foreignField: '_id',
+  justOne: true
+});
+
+fixtureSchema.virtual('awayTeam', {
+  ref: 'Team',
+  localField: 'awayTeamId',
+  foreignField: '_id',
+  justOne: true
+});
+
+// Static methods
+fixtureSchema.static('findBySlug', function (slug) {
+  return this.findOne({ slug });
+});
+
+fixtureSchema.static('getActive', function () {
+  return this.find({
+    status: { $in: [FixtureStatus.SCHEDULED, FixtureStatus.LIVE] }
+  }).sort({ scheduledAt: 1 });
+});
+
+fixtureSchema.static('findByExternalRef', function (bookmakerSlug, sportId, competitionId, externalId) {
+  const query = {};
+  query[`externalRefs.${bookmakerSlug}.id`] = externalId;
+  query['sportId'] = sportId;
+  query['competitionId'] = competitionId;
+  return this.findOne(query);
+});
+
+fixtureSchema.static('findByStatus', function (status) {
+  return this.find({ status }).sort({ scheduledAt: 1 });
+});
+
+fixtureSchema.static('findBySport', function (sportId) {
+  return this.find({ sportId }).sort({ scheduledAt: 1 });
+});
+
+fixtureSchema.static('findByCompetition', function (competitionId) {
+  return this.find({ competitionId }).sort({ scheduledAt: 1 });
+});
+
+fixtureSchema.static('findByTeam', function (teamId) {
+  return this.find({
+    $or: [{ homeTeamId: teamId }, { awayTeamId: teamId }]
+  }).sort({ scheduledAt: 1 });
+});
+
+fixtureSchema.static('findUpcoming', function (limit = 20) {
+  return this.find({
+    scheduledAt: { $gte: new Date() },
+    status: FixtureStatus.SCHEDULED
+  }).sort({ scheduledAt: 1 }).limit(limit);
+});
+
+fixtureSchema.static('findByDateRange', function (startDate, endDate) {
+  return this.find({
+    scheduledAt: { $gte: startDate, $lte: endDate }
+  }).sort({ scheduledAt: 1 });
+});
+
+// Instance methods
+fixtureSchema.method('activate', async function () {
+  this.status = FixtureStatus.SCHEDULED;
+  return this.save();
+});
+
+fixtureSchema.method('deactivate', async function () {
+  this.status = FixtureStatus.CANCELLED;
+  return this.save();
+});
+
+fixtureSchema.method('addExternalRef', async function (bookmakerSlug, externalId, data) {
+  // Convert array to object if needed (migration from old format)
+  if (Array.isArray(this.externalRefs)) {
+    this.externalRefs = {};
+  }
+  if (!this.externalRefs) {
+    this.externalRefs = {};
+  }
+  this.externalRefs[bookmakerSlug] = {
+    id: externalId,
+    name: data.name || '',
+    slug: data.slug || bookmakerSlug,
+    isActive: data.isActive !== undefined ? data.isActive : true,
+    metadata: data.metadata || {}
+  };
+  this.markModified('externalRefs');
+  return this.save();
+});
+
+fixtureSchema.method('getExternalRef', function (bookmakerSlug) {
+  return this.externalRefs?.[bookmakerSlug] || null;
+});
+
+fixtureSchema.method('removeExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    delete this.externalRefs[bookmakerSlug];
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+fixtureSchema.method('activateExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    this.externalRefs[bookmakerSlug].isActive = true;
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+fixtureSchema.method('deactivateExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    this.externalRefs[bookmakerSlug].isActive = false;
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+fixtureSchema.method('markAsLive', async function () {
+  this.status = FixtureStatus.LIVE;
+  return this.save();
+});
+
+fixtureSchema.method('markAsFinished', async function () {
+  this.status = FixtureStatus.FINISHED;
+  return this.save();
+});
+
+fixtureSchema.method('markAsPostponed', async function () {
+  this.status = FixtureStatus.POSTPONED;
+  return this.save();
+});
+
+fixtureSchema.method('markAsCancelled', async function () {
+  this.status = FixtureStatus.CANCELLED;
+  return this.save();
+});
+
+const Fixture = model('Fixture', fixtureSchema);
+
+module.exports = { Fixture, FixtureStatus };

package/models/index.js

@@ -0,0 +1,30 @@
+const { Bookmaker } = require('./bookmaker');
+const { Sport } = require('./sport');
+const { Competition } = require('./competition');
+const { Team } = require('./team');
+const { Player } = require('./player');
+const { Fixture, FixtureStatus } = require('./fixture');
+const { User } = require('./user');
+const { MarketTemplate } = require('./marketTemplate');
+const { Market } = require('./market');
+const { Odd } = require('./odd');
+const { OddDebug } = require('./oddDebug');
+const { BetTracker } = require('./betTracker');
+const { generateSlug } = require('./base');
+
+module.exports = {
+  Bookmaker,
+  Sport,
+  Competition,
+  Team,
+  Player,
+  Fixture,
+  FixtureStatus,
+  User,
+  MarketTemplate,
+  Market,
+  Odd,
+  OddDebug,
+  BetTracker,
+  generateSlug
+};

package/models/market.js

@@ -0,0 +1,38 @@
+const { Schema, model } = require('mongoose');
+const { createBaseSchema, baseSchemaOptions } = require('./base');
+
+/**
+ * Market schema - represents a priced market instance tied to a fixture/template
+ */
+const marketSchema = new Schema(
+  {
+    ...createBaseSchema(),
+
+    fixtureId: { type: String, required: true, ref: 'Fixture' },
+    marketTemplateId: { type: String, required: true, ref: 'MarketTemplate' },
+    marketTemplateName: { type: String, required: true },
+    specifiers: {
+      type: Schema.Types.Mixed,
+      default: {}
+    }
+  },
+  baseSchemaOptions
+);
+
+// Indexes to speed up lookups by fixture and template
+marketSchema.index({ fixtureId: 1 });
+marketSchema.index({ marketTemplateId: 1 });
+marketSchema.index({ fixtureId: 1, marketTemplateId: 1 });
+
+// Static methods
+marketSchema.static('findByFixtureAndMarketTemplate', function (fixtureId, marketTemplateId) {
+  return this.findOne({ fixtureId, marketTemplateId });
+});
+
+marketSchema.static('findBySpecifiers', function (fixtureId, marketTemplateId, specifiers) {
+  return this.findOne({ fixtureId, marketTemplateId, specifiers });
+});
+
+const Market = model('Market', marketSchema);
+
+module.exports = { Market };

package/models/marketTemplate.js

@@ -0,0 +1,102 @@
+const { Schema, model } = require('mongoose');
+const { createBaseSchema, baseSchemaOptions } = require('./base');
+
+/**
+ * Market Template schema - defines standardized market types and bookmaker mappings
+ */
+const marketTemplateSchema = new Schema(
+  {
+    ...createBaseSchema(),
+
+    sportId: { type: String, required: true, ref: 'Sport' },
+    name: { type: String, required: true },
+    slug: { type: String, unique: true, sparse: true },
+    category: {
+      type: String,
+      required: true,
+      enum: ['player-props', 'match-outcome', 'handicaps']
+    },
+
+    // Standardized outcome types for this market template
+    outcomes: [{
+      code: { type: String, required: true },  // 'over', 'under', '1', 'x', '2', etc.
+      name: { type: String, required: true }   // Display name
+    }],
+
+    // Required specifier keys with their properties
+    // Format: { player: ['name', 'id'], total: ['value'] }
+    specifierKeys: {
+      type: Schema.Types.Mixed,
+      default: {}
+    },
+
+    // Bookmaker-specific mappings
+    externalRefs: {
+      type: Schema.Types.Mixed,
+      default: {}
+      /*
+        Structure per bookmaker:
+        {
+          superbet: {
+            marketId: 233565,
+            method: 'outcomeId',  // How to identify outcome type
+            outcomes: [
+              { code: 'over', outcomeId: 5788 },
+              { code: 'under', outcomeId: 5787 }
+            ],
+            keys: {
+              player: { path: 'specifiers.player', idPath: 'extra.huddle-player-id' },
+              total: { path: 'specifiers.total' }
+            }
+          }
+        }
+      */
+    },
+
+    metadata: { type: Schema.Types.Mixed, default: {} }
+  },
+  baseSchemaOptions
+);
+
+// Indexes
+marketTemplateSchema.index({ slug: 1 });
+marketTemplateSchema.index({ category: 1 });
+marketTemplateSchema.index({ sportId: 1 });
+marketTemplateSchema.index({ 'externalRefs.superbet.marketId': 1 });
+
+// Pre-save hook to auto-generate slug from name
+marketTemplateSchema.pre('save', function (next) {
+  if (!this.slug && this.name) {
+    this.slug = this.name
+      .toLowerCase()
+      .trim()
+      .replace(/[^\w\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-');
+  }
+  next();
+});
+
+// Static methods
+marketTemplateSchema.static('findBySport', function (sportId) {
+  return this.find({ sportId });
+});
+
+marketTemplateSchema.static('findBySlug', function (slug) {
+  return this.findOne({ slug });
+});
+
+marketTemplateSchema.static('findByBookmakerMarketId', function (bookmakerSlug, marketId) {
+  const query = {};
+  query[`externalRefs.${bookmakerSlug}.marketId`] = marketId;
+  return this.findOne(query);
+});
+
+marketTemplateSchema.static('findByCategory', function (category) {
+  return this.find({ category });
+});
+
+const MarketTemplate = model('MarketTemplate', marketTemplateSchema);
+
+module.exports = { MarketTemplate };
+

package/models/odd.js

@@ -0,0 +1,78 @@
+const { Schema, model } = require('mongoose');
+const { createBaseSchema, baseSchemaOptions } = require('./base');
+
+/**
+ * Odd schema - represents a priced market instance tied to a fixture/template
+ */
+const oddSchema = new Schema(
+  {
+    ...createBaseSchema(),
+
+    bookmakerId: { type: String, required: true, ref: 'Bookmaker' },
+    bookmakerName: { type: String },
+    fixtureId: { type: String, required: true, ref: 'Fixture' },
+    fixtureName: { type: String },
+    marketId: { type: String, required: true, ref: 'Market' },
+    marketTemplateName: { type: String },
+    externalMarketId: { type: String },
+    externalMarketUuid: { type: String },
+    externalMarketName: { type: String },
+    externalOutcomeId: { type: String },
+    externalOutcomeUuid: { type: String },
+    code: { type: String },
+    name: { type: String },
+    price: { type: Number, required: true },
+    status: { type: String, enum: ['active', 'suspended', 'settled', 'block'], default: 'active' }
+  },
+  baseSchemaOptions
+);
+
+// Indexes to speed up lookups by fixture and template
+oddSchema.index({ bookmakerId: 1 });
+oddSchema.index({ marketId: 1 });
+oddSchema.index({ bookmakerId: 1, marketId: 1 });
+
+// Virtuals
+oddSchema.virtual('bookmaker', {
+  ref: 'Bookmaker',
+  localField: 'bookmakerId',
+  foreignField: '_id',
+  justOne: true
+});
+
+oddSchema.virtual('fixture', {
+  ref: 'Fixture',
+  localField: 'fixtureId',
+  foreignField: '_id',
+  justOne: true
+});
+
+oddSchema.virtual('market', {
+  ref: 'Market',
+  localField: 'marketId',
+  foreignField: '_id',
+  justOne: true
+});
+
+// Static methods
+oddSchema.static('findByBookmakerAndMarket', function (bookmakerId, marketId) {
+  return this.findOne({ bookmakerId, marketId });
+});
+
+oddSchema.static('findByExternalOutcomeUuid', function (bookmakerId, externalOutcomeUuid) {
+  const query = {};
+  query['bookmakerId'] = bookmakerId;
+  query['externalOutcomeUuid'] = externalOutcomeUuid;
+  return this.findOne(query);
+});
+
+oddSchema.static('findByExternalOutcomeId', function (bookmakerId, externalOutcomeId) {
+  const query = {};
+  query['bookmakerId'] = bookmakerId;
+  query['externalOutcomeId'] = externalOutcomeId;
+  return this.findOne(query);
+});
+
+const Odd = model('Odd', oddSchema);
+
+module.exports = { Odd };

package/models/oddDebug.js

@@ -0,0 +1,32 @@
+const { Schema, model } = require('mongoose');
+const { createBaseSchema, baseSchemaOptions } = require('./base');
+
+/**
+ * OddDebug schema - stores debugging information for odds
+ */
+const oddDebugSchema = new Schema(
+  {
+    ...createBaseSchema(),
+
+    bookmakerId: { type: String, required: true, ref: 'Bookmaker' },
+    oddId: { type: String, required: true, ref: 'Odd' },
+    fixtureId: { type: String, required: true, ref: 'Fixture' },
+    debugData: { type: Schema.Types.Mixed, default: {} }
+  },
+  baseSchemaOptions
+);
+
+// Indexes to speed up lookups by fixture and template
+oddDebugSchema.index({ bookmakerId: 1 });
+oddDebugSchema.index({ oddId: 1 });
+oddDebugSchema.index({ fixtureId: 1 });
+oddDebugSchema.index({ bookmakerId: 1, oddId: 1, fixtureId: 1 }, { unique: true });
+
+// Static methods
+oddDebugSchema.static('findByBookmakerAndOdd', function (bookmakerId, oddId) {
+  return this.findOne({ bookmakerId, oddId });
+});
+
+const OddDebug = model('OddDebug', oddDebugSchema);
+
+module.exports = { OddDebug };

package/models/player.js

@@ -0,0 +1,140 @@
+const { Schema, model } = require('mongoose');
+const {
+  createBaseSchema,
+  baseSchemaOptions,
+  addAutoSlugHook,
+  addExternalRefsSlugHook
+} = require('./base');
+
+/**
+ * Player schema
+ */
+const playerSchema = new Schema(
+  {
+    ...createBaseSchema(),
+    sportId: { type: String, required: true, ref: 'Sport' },
+    teamId: { type: String, required: true, ref: 'Team' },
+    resourceId: { type: String },
+    fullName: { type: String, required: true },
+    firstName: { type: String },
+    lastName: { type: String },
+    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
+playerSchema.index({ slug: 1 });
+playerSchema.index({ sportId: 1 });
+playerSchema.index({ isActive: 1 });
+playerSchema.index({ fullName: 'text' });
+
+// Virtuals
+playerSchema.virtual('sport', {
+  ref: 'Sport',
+  localField: 'sportId',
+  foreignField: '_id',
+  justOne: true
+});
+
+playerSchema.virtual('team', {
+  ref: 'Team',
+  localField: 'teamId',
+  foreignField: '_id',
+  justOne: true
+});
+
+// Add auto-slug generation from fullName field
+addAutoSlugHook(playerSchema, 'fullName');
+
+// Static methods
+playerSchema.static('findBySlug', function (slug) {
+  return this.findOne({ slug });
+});
+
+playerSchema.static('getActive', function () {
+  return this.find({ isActive: true }).sort({ name: 1 });
+});
+
+playerSchema.static('findByExternalRefId', function (bookmakerSlug, sportId, externalId) {
+  const query = {};
+  query[`externalRefs.${bookmakerSlug}.id`] = externalId;
+  query['sportId'] = sportId;
+  return this.findOne(query);
+});
+
+playerSchema.static('findBySport', function (sportId) {
+  return this.find({ sportId, isActive: true }).sort({ fullName: 1 });
+});
+
+playerSchema.static('findByTeam', function (teamId) {
+  return this.find({ teamId, isActive: true }).sort({ fullName: 1 });
+});
+
+playerSchema.static('searchByFullName', function (query) {
+  return this.find({
+    fullName: { $regex: query, $options: 'i' }
+  }).sort({ fullName: 1 });
+});
+
+// Instance methods
+playerSchema.method('activate', async function () {
+  this.isActive = true;
+  return this.save();
+});
+
+playerSchema.method('deactivate', async function () {
+  this.isActive = false;
+  return this.save();
+});
+
+playerSchema.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();
+});
+
+playerSchema.method('getExternalRef', function (bookmakerSlug) {
+  return this.externalRefs?.[bookmakerSlug] || null;
+});
+
+playerSchema.method('removeExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    delete this.externalRefs[bookmakerSlug];
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+playerSchema.method('activateExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    this.externalRefs[bookmakerSlug].isActive = true;
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+playerSchema.method('deactivateExternalRef', async function (bookmakerSlug) {
+  if (this.externalRefs?.[bookmakerSlug]) {
+    this.externalRefs[bookmakerSlug].isActive = false;
+    this.markModified('externalRefs');
+    return this.save();
+  }
+  return this;
+});
+
+const Player = model('Player', playerSchema);
+
+module.exports = { Player };