@winible/winible-typed 2.0.0 → 2.1.0

package/typed-model/{subscription.ts → subscription-plan-on-users.ts}

@@ -4,33 +4,25 @@ import {
   InferCreationAttributes,
   CreationOptional,
   DataTypes,
-  fn,
-  NOW,
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";
-import PhoneOwner from "./phone-owner";
-import PhoneUser from "./phone-user";
+import SubscriptionPlan from "./subscription-plan";
+import User from "./user";
 
 // order of InferAttributes & InferCreationAttributes is important.
-class Subscription extends Model<
-  InferAttributes<Subscription>,
-  InferCreationAttributes<Subscription>
+class SubscriptionPlanOnUsers extends Model<
+  InferAttributes<SubscriptionPlanOnUsers>,
+  InferCreationAttributes<SubscriptionPlanOnUsers>
 > {
   // '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 userId: string;
   declare subscriptionPlanId: string;
-
-  declare paypalSubscriptionId?: string;
-  declare paypalOrderId?: string;
-  declare paypalBillingToken?: string;
   declare lastPaymentDate?: Date;
   declare cancelDate?: Date;
-  declare pkSubscriptionId?: string;
   declare numberOfPayments?: number;
-  declare subscriptionPromotionId?: string;
   declare recurlySubscriptionId?: string;
   declare status?:
     | "active"
@@ -43,17 +35,16 @@ class Subscription extends Model<
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
 
-  static getById: (id: string) => Promise<Subscription | null>;
-  static getByUserId: (userId: string) => Promise<Subscription | null>;
+  static getById: (id: string) => Promise<SubscriptionPlanOnUsers | null>;
+  static getByUserId: (
+    userId: string
+  ) => Promise<SubscriptionPlanOnUsers | null>;
   static getBySubscriptionPlanId: (
     subscriptionPlanId: string
-  ) => Promise<Subscription | null>;
-  static getByPaypalSubscriptionId: (
-    paypalSubscriptionId: string
-  ) => Promise<Subscription | null>;
+  ) => Promise<SubscriptionPlanOnUsers | null>;
 }
 
-Subscription.init(
+SubscriptionPlanOnUsers.init(
   {
     id: {
       type: DataTypes.BIGINT,
@@ -71,18 +62,6 @@ Subscription.init(
       allowNull: false,
       field: "subscription_plan_id",
     },
-    paypalSubscriptionId: {
-      type: DataTypes.STRING,
-      field: "paypal_subscription_id",
-    },
-    paypalOrderId: {
-      type: DataTypes.STRING,
-      field: "paypal_order_id",
-    },
-    paypalBillingToken: {
-      type: DataTypes.STRING,
-      field: "paypal_billing_token",
-    },
     lastPaymentDate: {
       type: DataTypes.DATE,
       field: "last_payment_date",
@@ -91,19 +70,11 @@ Subscription.init(
       type: DataTypes.DATE,
       field: "cancel_date",
     },
-    pkSubscriptionId: {
-      type: DataTypes.STRING,
-      field: "pk_subscription_id",
-    },
     numberOfPayments: {
       type: DataTypes.INTEGER,
       defaultValue: 0,
       field: "number_of_payments",
     },
-    subscriptionPromotionId: {
-      type: DataTypes.BIGINT,
-      field: "subscription_promotion_id",
-    },
     stale: {
       type: DataTypes.BOOLEAN,
       field: "stale",
@@ -123,7 +94,7 @@ Subscription.init(
     updatedAt: DataTypes.DATE,
   },
   {
-    tableName: "subscriptions",
+    tableName: "subscription_plan_on_users",
     sequelize,
   }
 );
@@ -134,41 +105,54 @@ Class functions
 ====================================================================
 */
 
-Subscription.getById = async (id: string) => {
-  return await Subscription.findOne({
+SubscriptionPlanOnUsers.getById = async (id: string) => {
+  return await SubscriptionPlanOnUsers.findOne({
     where: {
       id,
     },
   });
 };
 
-Subscription.getByUserId = async (userId: string) => {
-  return await Subscription.findOne({
+SubscriptionPlanOnUsers.getByUserId = async (userId: string) => {
+  return await SubscriptionPlanOnUsers.findOne({
     where: {
       userId,
     },
   });
 };
 
-Subscription.getBySubscriptionPlanId = async (subscriptionPlanId: string) => {
-  return await Subscription.findOne({
+SubscriptionPlanOnUsers.getBySubscriptionPlanId = async (
+  subscriptionPlanId: string
+) => {
+  return await SubscriptionPlanOnUsers.findOne({
     where: {
       subscriptionPlanId,
     },
   });
 };
 
-Subscription.getByPaypalSubscriptionId = async (
-  paypalSubscriptionId: string
-) => {
-  return await Subscription.findOne({
-    where: {
-      paypalSubscriptionId,
-    },
-  });
-};
+User.hasMany(SubscriptionPlanOnUsers, {
+  foreignKey: "userId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+SubscriptionPlanOnUsers.hasOne(User, {
+  foreignKey: "id",
+  sourceKey: "userId",
+});
+
+SubscriptionPlan.hasMany(SubscriptionPlanOnUsers, {
+  foreignKey: "subscriptionPlanId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
 
-Subscription.hasOne(PhoneUser, { foreignKey: "id", sourceKey: "userId" });
-PhoneUser.hasMany(Subscription, { foreignKey: "user_id", sourceKey: "id" });
+SubscriptionPlanOnUsers.hasOne(SubscriptionPlan, {
+  foreignKey: "id",
+  sourceKey: "subscriptionPlanId",
+});
 
-export default Subscription;
+export default SubscriptionPlanOnUsers;

package/typed-model/subscription-plan.ts

@@ -4,14 +4,12 @@ import {
   InferCreationAttributes,
   CreationOptional,
   DataTypes,
-  fn,
-  NOW,
   NonAttribute,
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";
-import PhoneOwner from "./phone-owner";
-import Subscription from "./subscription";
+import User from "./user";
+import SubscriptionPlanOnUsers from "./subscription-plan-on-users";
 
 // order of InferAttributes & InferCreationAttributes is important.
 class SubscriptionPlan extends Model<
@@ -21,30 +19,24 @@ class SubscriptionPlan 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 ownerId: string;
+  declare userId: string;
   declare planName?: string;
   declare amountInCents?: number;
   declare intervalCount?: number;
   declare intervalUnit: CreationOptional<"months" | "days">;
-  declare paypalPlanId: string;
-  declare paypalProductId: string;
   declare isArchived?: boolean;
-  declare productDescriptionList?: string[];
+  declare planDescription?: string;
   declare oneTimePurchase?: boolean;
   declare accessEndDate?: Date;
   declare recurlyPlanId?: string;
   declare order?: number;
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
+
   static getById: (id: string) => Promise<SubscriptionPlan | null>;
-  static getByOwnerId: (ownerId: string) => Promise<SubscriptionPlan | null>;
-  static getByPaypalPlanId: (
-    paypalPlanId: string
-  ) => Promise<SubscriptionPlan | null>;
+  static getByUserId: (ownerId: string) => Promise<SubscriptionPlan | null>;
 
-  declare subscriptions?: NonAttribute<Subscription[]>;
-  declare SubscriptionPromotions?: NonAttribute<any[]>;
-  declare SubscriptionBundles?: NonAttribute<any[]>;
+  declare subscriptions?: NonAttribute<SubscriptionPlanOnUsers[]>;
 }
 
 SubscriptionPlan.init(
@@ -55,10 +47,10 @@ SubscriptionPlan.init(
       allowNull: false,
       defaultValue: sequelize.fn("next_id"),
     },
-    ownerId: {
+    userId: {
       type: DataTypes.BIGINT,
       allowNull: false,
-      field: "owner_id",
+      field: "user_id",
     },
     planName: {
       type: DataTypes.STRING,
@@ -78,22 +70,14 @@ SubscriptionPlan.init(
       field: "interval_unit",
       defaultValue: "months",
     },
-    paypalPlanId: {
-      type: DataTypes.STRING,
-      field: "paypal_plan_id",
-    },
-    paypalProductId: {
-      type: DataTypes.STRING,
-      field: "paypal_product_id",
-    },
     isArchived: {
       type: DataTypes.BOOLEAN,
       field: "is_archived",
       defaultValue: false,
     },
-    productDescriptionList: {
-      type: DataTypes.ARRAY(DataTypes.STRING),
-      field: "product_description_list",
+    planDescription: {
+      type: DataTypes.STRING,
+      field: "plan_description",
     },
     oneTimePurchase: {
       type: DataTypes.BOOLEAN,
@@ -136,37 +120,36 @@ SubscriptionPlan.getById = async (id: string) => {
   });
 };
 
-SubscriptionPlan.getByOwnerId = async (ownerId: string) => {
-  return await SubscriptionPlan.findOne({
-    where: {
-      ownerId,
-    },
-  });
-};
-
-SubscriptionPlan.getByPaypalPlanId = async (paypalPlanId: string) => {
+SubscriptionPlan.getByUserId = async (userId: string) => {
   return await SubscriptionPlan.findOne({
     where: {
-      paypalPlanId,
+      userId,
     },
   });
 };
 
-SubscriptionPlan.hasMany(Subscription, { foreignKey: "subscription_plan_id" });
-Subscription.hasOne(SubscriptionPlan, {
-  foreignKey: "id",
-  sourceKey: "subscription_plan_id",
+SubscriptionPlan.hasMany(SubscriptionPlanOnUsers, {
+  foreignKey: "subscriptionPlanId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
 });
 
-SubscriptionPlan.hasOne(PhoneOwner, {
+SubscriptionPlanOnUsers.hasOne(SubscriptionPlan, {
   foreignKey: "id",
-  sourceKey: "ownerId",
+  sourceKey: "subscriptionPlanId",
 });
-PhoneOwner.hasMany(SubscriptionPlan, {
-  foreignKey: "owner_id",
+
+User.hasMany(SubscriptionPlan, {
+  foreignKey: "userId",
   sourceKey: "id",
   onDelete: "NO ACTION",
   constraints: false,
 });
 
+SubscriptionPlan.hasOne(User, {
+  foreignKey: "id",
+  sourceKey: "userId",
+});
+
 export default SubscriptionPlan;

package/typed-model/transaction.ts

@@ -0,0 +1,154 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import User from "./user";
+import Notification from "./notification";
+
+type TransactionType =
+  | "subscription"
+  | "tip"
+  | "text"
+  | "unlock_message"
+  | "content"
+  | "unlock"
+  | "audio"
+  | "referral"
+  | "video";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class Transaction extends Model<
+  InferAttributes<Transaction>,
+  InferCreationAttributes<Transaction>
+> {
+  // '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 payerId?: string;
+  declare recipientId?: string;
+  declare transactionAmountInCents: number;
+  declare transactionType: TransactionType;
+  declare withdrawalId?: string;
+  declare withdrawalDate?: Date;
+  declare metadata?: string;
+  declare earningAmountInCents: number;
+  declare referredTransactionId?: string;
+  declare recurlyInvoiceId?: string;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+
+  static getById: (id: string) => Promise<Transaction | null>;
+}
+
+Transaction.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    payerId: {
+      type: DataTypes.BIGINT,
+      field: "payer_id",
+    },
+    recipientId: {
+      type: DataTypes.BIGINT,
+      field: "recipient_id",
+    },
+    transactionAmountInCents: {
+      type: DataTypes.INTEGER,
+      field: "transaction_amount_in_cents",
+    },
+    transactionType: {
+      type: DataTypes.STRING,
+      field: "transaction_type",
+    },
+    withdrawalId: {
+      type: DataTypes.BIGINT,
+      field: "withdrawal_id",
+    },
+    withdrawalDate: {
+      type: DataTypes.DATE,
+      field: "withdrawal_date",
+    },
+    metadata: {
+      type: DataTypes.STRING,
+      field: "metadata",
+    },
+    earningAmountInCents: {
+      type: DataTypes.INTEGER,
+      field: "earning_amount_in_cents",
+    },
+    referredTransactionId: {
+      type: DataTypes.BIGINT,
+      field: "referred_transaction_id",
+    },
+    recurlyInvoiceId: {
+      type: DataTypes.STRING,
+      field: "recurly_invoice_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "credit_payments",
+    sequelize,
+  }
+);
+
+const REFERRAL_PERCENTAGE = 0.03;
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+Transaction.getById = async (id: string) => {
+  return await Transaction.findOne({
+    where: {
+      id,
+    },
+  });
+};
+
+User.hasMany(Transaction, {
+  foreignKey: "payerId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+Transaction.hasOne(User, {
+  foreignKey: "id",
+  sourceKey: "payerId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+User.hasMany(Transaction, {
+  foreignKey: "recipientId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+Transaction.hasOne(User, {
+  foreignKey: "id",
+  sourceKey: "recipientId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+Notification.hasOne(Transaction, {
+  foreignKey: "id",
+  sourceKey: "transactionId",
+  constraints: false,
+  onDelete: "NO ACTION",
+});
+
+export default Transaction;

package/typed-model/user.ts

@@ -28,8 +28,8 @@ class User extends Model<InferAttributes<User>, InferCreationAttributes<User>> {
   declare password?: string;
   declare username?: string;
   declare emailVerified?: boolean;
-  declare userStatus?: string;
-  declare userRole?: string;
+  declare userStatus?: UserStatus;
+  declare userRole?: UserRole;
   declare phoneNumber?: string;
 
   declare bio?: string;

package/typed-model/{credit-payout.ts → withdrawal.ts}

@@ -4,27 +4,25 @@ import {
   InferCreationAttributes,
   CreationOptional,
   DataTypes,
-  fn,
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";
 
 // order of InferAttributes & InferCreationAttributes is important.
-class CreditPayout extends Model<
-  InferAttributes<CreditPayout>,
-  InferCreationAttributes<CreditPayout>
+class Withdrawal extends Model<
+  InferAttributes<Withdrawal>,
+  InferCreationAttributes<Withdrawal>
 > {
   // '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 ownerId: string;
-  declare agencyId?: string;
+  declare userId: string;
   declare amountInCents: number;
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
 }
 
-CreditPayout.init(
+Withdrawal.init(
   {
     id: {
       type: DataTypes.BIGINT,
@@ -32,13 +30,9 @@ CreditPayout.init(
       allowNull: false,
       defaultValue: sequelize.fn("next_id"),
     },
-    ownerId: {
+    userId: {
       type: DataTypes.BIGINT,
-      field: "owner_id",
-    },
-    agencyId: {
-      type: DataTypes.BIGINT,
-      field: "agency_id",
+      field: "user_id",
     },
     amountInCents: {
       type: DataTypes.INTEGER,
@@ -48,15 +42,9 @@ CreditPayout.init(
     updatedAt: DataTypes.DATE,
   },
   {
-    tableName: "credit_payouts",
+    tableName: "withdrawals",
     sequelize,
   }
 );
 
-/*
-    ====================================================================
-    Class functions
-    ====================================================================
-    */
-
-export default CreditPayout;
+export default Withdrawal;