@winible/winible-typed 2.70.5 → 2.71.0

package/src/types.ts

@@ -164,3 +164,49 @@ export interface TemplatePrompt {
 export interface ComplianceStatus {
   [key: string]: any;
 }
+
+export enum StatusType {
+  ACTIVE = "active",
+  INACTIVE = "inactive",
+}
+
+export enum BetType {
+  STRAIGHT = "straight",
+  PARLAY = "parlay",
+}
+
+export enum BetStatusType {
+  WON = "won",
+  LOST = "lost",
+  OPEN = "open",
+  VOID = "void",
+}
+
+export enum AffiliateLinkLinkTypes {
+  WINIBLE = "winible",
+  CREATOR = "creator",
+  WINIBLE_CREATOR = "winible_creator",
+}
+
+export type OddDeepLinkType = {
+  ios?: string;
+  android?: string;
+  desktop?: string;
+};
+
+export type OddAssetsType = {
+  home_competitor?: {
+    name: string;
+    abbreviation: string;
+    logo: string;
+  };
+  away_competitor?: {
+    name: string;
+    abbreviation: string;
+    logo: string;
+  };
+  player?: {
+    name: string;
+    logo: string;
+  };
+};

package/typed-model/affiliate-link.ts

@@ -0,0 +1,104 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import { AffiliateLinkLinkTypes, StatusType } from "../src/types";
+import User from "./user";
+import Sportsbook from "./sportsbook";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class AffiliateLinks extends Model<
+  InferAttributes<AffiliateLinks>,
+  InferCreationAttributes<AffiliateLinks>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare creatorId: string;
+  declare sportsbookId: string;
+  declare type: AffiliateLinkLinkTypes;
+  declare cta: string;
+  declare affiliateCode: string;
+  declare affiliateLink: string;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+AffiliateLinks.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    creatorId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      references: {
+        model: User,
+        key: "id",
+      },
+      field: "creator_id",
+    },
+    sportsbookId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      references: {
+        model: Sportsbook,
+        key: "id",
+      },
+      field: "sportsbook_id",
+    },
+    type: {
+      type: DataTypes.ENUM(...Object.values(AffiliateLinkLinkTypes)),
+      allowNull: false,
+    },
+    cta: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    affiliateCode: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      field: "affiliate_code",
+    },
+    affiliateLink: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      field: "affiliate_link",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    // Other model options go here
+    tableName: "affiliate_links",
+    comment: "Affiliate Links table, belongs to a user (creator_id)",
+    sequelize,
+  }
+);
+
+User.hasMany(AffiliateLinks, {
+  foreignKey: "creatorId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+AffiliateLinks.belongsTo(User, { foreignKey: "creatorId" });
+
+Sportsbook.hasMany(AffiliateLinks, {
+  foreignKey: "sportsbookId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+export default AffiliateLinks;

package/typed-model/bet-sport.ts

@@ -0,0 +1,61 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import { StatusType } from "../src/types";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class BetSport extends Model<
+  InferAttributes<BetSport>,
+  InferCreationAttributes<BetSport>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare name: string;
+  declare status: StatusType;
+  declare numericalId: number;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+BetSport.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    status: {
+      type: DataTypes.ENUM(...Object.values(StatusType)),
+      allowNull: false,
+    },
+    numericalId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      comment: "Numerical ID provided by Odds Jam",
+      field: "numerical_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    // Other model options go here
+    tableName: "bet_sports",
+    comment: "Bet sports synched from Odds Jam",
+    sequelize,
+  }
+);
+
+export default BetSport;

package/typed-model/bet.ts

@@ -7,37 +7,15 @@ import {
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";
-import User from "./user";
 import Post from "./post";
-
-type BetType = "same-game parlay" | "parlay" | "single";
-type ResultType = "pending" | "won" | "lost" | "push";
+import { BetStatusType, BetType } from "../src/types";
 
 // order of InferAttributes & InferCreationAttributes is important.
 class Bet extends Model<InferAttributes<Bet>, InferCreationAttributes<Bet>> {
   declare id: CreationOptional<string>;
-  declare userId: string;
   declare postId: string;
+  declare status: BetStatusType;
   declare type: BetType;
-  declare stakeInCents?: number;
-  declare returnInCents?: number;
-  declare stakeInUnits?: number;
-  declare returnInUnits?: number;
-  declare settled: boolean;
-  declare result?: ResultType;
-  declare events?: {
-    sport: string;
-    homeTeam: string;
-    awayTeam?: string;
-    league?: string;
-    odds: {
-      value: number | null;
-      market: string;
-      title: string;
-    }[];
-  }[];
-  declare metadata?: any;
-
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
 }
@@ -50,14 +28,6 @@ Bet.init(
       allowNull: false,
       defaultValue: sequelize.fn("next_id"),
     },
-    userId: {
-      type: DataTypes.BIGINT,
-      allowNull: false,
-      field: "user_id",
-      references: {
-        model: User,
-      },
-    },
     postId: {
       type: DataTypes.BIGINT,
       allowNull: false,
@@ -66,70 +36,21 @@ Bet.init(
         model: Post,
       },
     },
-    type: {
-      type: DataTypes.STRING,
-      allowNull: false,
-      field: "type",
-    },
-    stakeInCents: {
-      type: DataTypes.INTEGER,
-      allowNull: true,
-      field: "stake_in_cents",
-      comment: "The amount of stake in cents (e.g., 5000 for $50)",
-    },
-    returnInCents: {
-      type: DataTypes.INTEGER,
-      allowNull: true,
-      field: "return_in_cents",
-      comment: "The potential return amount in cents",
-    },
-    stakeInUnits: {
-      type: DataTypes.FLOAT,
-      allowNull: true,
-      field: "stake_in_units",
-      comment: "The amount of stake in units (e.g., 1.0 for 1 unit)",
-    },
-    returnInUnits: {
-      type: DataTypes.FLOAT,
-      allowNull: true,
-      field: "return_in_units",
-      comment: "The potential return amount in units",
-    },
-    settled: {
-      type: DataTypes.BOOLEAN,
-      allowNull: false,
-      defaultValue: false,
-      field: "settled",
-    },
-    result: {
-      type: DataTypes.STRING,
-      allowNull: true,
-      field: "result",
-      comment: "Result of the bet: pending, won, lost, push",
-    },
-    events: {
-      type: DataTypes.JSONB,
-      allowNull: true,
-      field: "events",
-    },
-    metadata: {
-      type: DataTypes.JSONB,
-      allowNull: true,
-      field: "metadata",
-    },
-    createdAt: {
-      type: DataTypes.DATE,
+    status: {
+      type: DataTypes.ENUM(...Object.values(BetStatusType)),
       allowNull: false,
-      field: "created_at",
     },
-    updatedAt: {
-      type: DataTypes.DATE,
+    type: {
+      type: DataTypes.ENUM(...Object.values(BetType)),
       allowNull: false,
-      field: "updated_at",
     },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
   },
   {
     tableName: "bets",
+    comment:
+      "Bets table, relates a post to a bet and it's available odds or parlays",
     sequelize,
   }
 );

package/typed-model/index.ts

@@ -14,8 +14,6 @@ export { default as SubscriptionPricingOption } from "./subscription-pricing-opt
 export { default as FreeSubscriptionPlan } from "./free-subscription-plan";
 export { default as RecurlyAccount } from "./recurly-account";
 export { default as Withdrawal } from "./withdrawal";
-export { default as League } from "./league";
-export { default as LeagueOnUsers } from "./league-on-users";
 export { default as User } from "./user";
 export { default as SubscriptionPricingOptionOnCoupons } from "./subscription-pricing-option-on-coupons";
 export { default as SubscribersOnCreators } from "./subscribers-on-creators";
@@ -69,5 +67,16 @@ export { default as PhoneNumberAssignment } from "./phone-number-assignment";
 export { default as SendgridEmailSubAccount } from "./sendgrid-email-sub-account";
 export { default as SendgridIpPool } from "./sendgrid-ip-pool";
 export { default as SendgridDomain } from "./sendgrid-domain";
+export { default as BetSport } from "./bet-sport";
+export { default as Market } from "./market";
+export { default as League } from "./league";
+export { default as MarketOnBetSport } from "./market-on-bet-sport";
+export { default as AffiliateLink } from "./affiliate-link";
+export { default as Sportsbook } from "./sportsbook";
+export { default as Odd } from "./odd";
+export { default as Parlay } from "./parlay";
+export { default as OddsOnBets } from "./odds-on-bets";
+export { default as OddsOnParlays } from "./odds-on-parlays";
+export { default as ParlaysOnBets } from "./parlays-on-bets";
 
 export { default as pbSequelize } from "./pb-sequelize";

package/typed-model/league.ts

@@ -8,6 +8,8 @@ import {
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";
+import { StatusType } from "../src/types";
+import BetSport from "./bet-sport";
 
 // order of InferAttributes & InferCreationAttributes is important.
 class League extends Model<
@@ -17,8 +19,12 @@ class League extends Model<
   // 'CreationOptional' is a special type that marks the field as optional
   // when creating an instance of the model (such as using Model.create()).
   declare id: CreationOptional<string>;
-  declare sport: string;
-  declare leagueName: string;
+  declare name: string;
+  declare status: StatusType;
+  declare numericalId: number;
+  declare region: string;
+  declare regionCode: string;
+  declare betSportsId: string;
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
 }
@@ -31,14 +37,37 @@ League.init(
       allowNull: false,
       defaultValue: sequelize.fn("next_id"),
     },
-    sport: {
+    name: {
       type: DataTypes.STRING,
-      field: "sport",
+      allowNull: false,
+    },
+    status: {
+      type: DataTypes.ENUM(...Object.values(StatusType)),
+      allowNull: false,
+    },
+    numericalId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      comment: "Numerical ID provided by Odds Jam",
+      field: "numerical_id",
+    },
+    region: {
+      type: DataTypes.STRING,
+      allowNull: false,
     },
-    leagueName: {
+    regionCode: {
       type: DataTypes.STRING,
-      field: "league_name",
-      unique: true,
+      allowNull: false,
+      field: "region_code",
+    },
+    betSportsId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      references: {
+        model: BetSport,
+        key: "id",
+      },
+      field: "bet_sports_id",
     },
     createdAt: DataTypes.DATE,
     updatedAt: DataTypes.DATE,
@@ -46,8 +75,18 @@ League.init(
   {
     // Other model options go here
     tableName: "leagues",
+    comment: "Leagues synched from Odds Jam",
     sequelize,
   }
 );
 
+BetSport.hasMany(League, {
+  foreignKey: "betSportsId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+League.belongsTo(BetSport, { foreignKey: "betSportsId" });
+
 export default League;

package/typed-model/market-on-bet-sport.ts

@@ -0,0 +1,76 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import { StatusType } from "../src/types";
+import BetSport from "./bet-sport";
+import Market from "./market";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class MarketOnBetSport extends Model<
+  InferAttributes<MarketOnBetSport>,
+  InferCreationAttributes<MarketOnBetSport>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare betSportId: string;
+  declare marketId: string;
+  declare status: StatusType;
+}
+
+MarketOnBetSport.init(
+  {
+    betSportId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      references: {
+        model: BetSport,
+        key: "id",
+      },
+      field: "bet_sport_id",
+    },
+    marketId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      references: {
+        model: Market,
+        key: "id",
+      },
+      field: "market_id",
+    },
+    status: {
+      type: DataTypes.ENUM(...Object.values(StatusType)),
+      allowNull: false,
+    },
+  },
+  {
+    tableName: "markets_on_bet_sports",
+    comment: "Junction table that relates a bet_sport to a market",
+    timestamps: false,
+    sequelize,
+  }
+);
+
+BetSport.belongsToMany(Market, {
+  through: MarketOnBetSport,
+  foreignKey: "betSportId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+Market.belongsToMany(BetSport, {
+  through: MarketOnBetSport,
+  foreignKey: "marketId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+export default MarketOnBetSport;

package/typed-model/market.ts

@@ -0,0 +1,55 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class Market extends Model<
+  InferAttributes<Market>,
+  InferCreationAttributes<Market>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare name: string;
+  declare numericalId: number;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+Market.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    numericalId: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      comment: "Numerical ID provided by Odds Jam",
+      field: "numerical_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    // Other model options go here
+    tableName: "markets",
+    comment: "Markets synched from Odds Jam",
+    sequelize,
+  }
+);
+
+export default Market;