@winible/winible-typed 2.0.1 → 2.1.0

package/typed-model/content-like.ts

@@ -4,11 +4,11 @@ import {
   InferCreationAttributes,
   CreationOptional,
   DataTypes,
-  fn,
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";
-import PhoneUser from "./phone-user";
+import Post from "./post";
+import User from "./user";
 
 // order of InferAttributes & InferCreationAttributes is important.
 class ContentLike extends Model<
@@ -18,10 +18,11 @@ class ContentLike 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 contentId: string;
+  declare postId: string;
   declare userId: string;
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
+
   static getById: (id: string) => Promise<ContentLike | null>;
 }
 
@@ -33,9 +34,9 @@ ContentLike.init(
       allowNull: false,
       defaultValue: sequelize.fn("next_id"),
     },
-    contentId: {
+    postId: {
       type: DataTypes.INTEGER,
-      field: "content_id",
+      field: "post_id",
     },
     userId: {
       type: DataTypes.STRING,
@@ -47,21 +48,9 @@ ContentLike.init(
   {
     sequelize,
     tableName: "content_likes",
-    // Other model options go here
   }
 );
 
-PhoneUser.hasMany(ContentLike, {
-  foreignKey: "user_id",
-  onDelete: "NO ACTION",
-  constraints: false,
-});
-ContentLike.hasOne(PhoneUser, {
-  foreignKey: "id",
-  sourceKey: "user_id",
-  onDelete: "NO ACTION",
-  constraints: false,
-});
 /*
 ====================================================================
 Class functions
@@ -76,4 +65,31 @@ ContentLike.getById = async (id: string) => {
   });
 };
 
+Post.hasMany(ContentLike, {
+  foreignKey: "postId",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+ContentLike.hasOne(Post, {
+  foreignKey: "id",
+  sourceKey: "postId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+User.hasMany(ContentLike, {
+  foreignKey: "userId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+ContentLike.hasOne(User, {
+  foreignKey: "id",
+  sourceKey: "userId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
 export default ContentLike;

package/typed-model/index.ts

@@ -1,16 +1,15 @@
 export { default as ContentLike } from "./content-like";
-export { default as CreditPayments } from "./credit-payment";
+export { default as Transaction } from "./transaction";
 export { default as MediaAsset } from "./media-asset";
 export { default as Media } from "./media";
 export { default as Notification } from "./notification";
 export { default as pbSequelize } from "./pb-sequelize";
-export { default as PhoneOwner } from "./phone-owner";
-export { default as PhoneUser } from "./phone-user";
-export { default as PremiumContent } from "./premium-content";
-export { default as PurchasedContent } from "./purchased-content";
+export { default as Post } from "./post";
+export { default as PostsOnUsers } from "./posts-on-users";
 export { default as SubscriptionPlan } from "./subscription-plan";
-export { default as Subscription } from "./subscription";
+export { default as SubscriptionPlanOnUsers } from "./subscription-plan-on-users";
+export { default as SubscriptionPlanOnPost } from "./subscription-plan-on-post";
 export { default as RecurlyAccount } from "./recurly-account";
-export { default as CreditPayout } from "./credit-payout";
+export { default as Withdrawal } from "./withdrawal";
 export { default as League } from "./league";
 export { default as User } from "./user";

package/typed-model/league-user.ts

@@ -8,7 +8,7 @@ import {
 import League from "./league";
 
 import sequelize from "./pb-sequelize";
-import PhoneUser from "./phone-user";
+import User from "./user";
 
 // order of InferAttributes & InferCreationAttributes is important.
 class LeagueUser extends Model<
@@ -58,19 +58,21 @@ LeagueUser.hasOne(League, {
   onDelete: "NO ACTION",
   constraints: false,
 });
+
 League.hasMany(LeagueUser, {
   foreignKey: "leagueId",
   onDelete: "NO ACTION",
   constraints: false,
 });
 
-LeagueUser.hasOne(PhoneUser, {
+LeagueUser.hasOne(User, {
   foreignKey: "id",
   sourceKey: "userId",
   onDelete: "NO ACTION",
   constraints: false,
 });
-PhoneUser.hasMany(LeagueUser, {
+
+User.hasMany(LeagueUser, {
   foreignKey: "userId",
   onDelete: "NO ACTION",
   constraints: false,

package/typed-model/media.ts

@@ -4,7 +4,6 @@ import {
   InferCreationAttributes,
   CreationOptional,
   DataTypes,
-  fn,
   NonAttribute,
 } from "sequelize";
 import MediaAsset from "./media-asset";
@@ -20,8 +19,7 @@ class Media extends Model<
   // when creating an instance of the model (such as using Model.create()).
   declare id: CreationOptional<string>;
   declare mediaAssetId: string;
-  declare premiumContentId?: string;
-  declare messageMediaId?: string;
+  declare postId?: string;
   declare order?: number;
   declare isPreview?: boolean;
   declare createdAt: CreationOptional<Date>;
@@ -42,13 +40,9 @@ Media.init(
       type: DataTypes.BIGINT,
       field: "media_asset_id",
     },
-    premiumContentId: {
+    postId: {
       type: DataTypes.BIGINT,
-      field: "premium_content_id",
-    },
-    messageMediaId: {
-      type: DataTypes.BIGINT,
-      field: "message_media_id",
+      field: "post_id",
     },
     order: {
       type: DataTypes.INTEGER,

package/typed-model/pb-sequelize.ts

@@ -23,7 +23,7 @@ const dbUrl =
 //     },
 //   },
 // });
-export default new Sequelize({
+const sequelize = new Sequelize({
   username: "postgres",
   password: "l5WFq6a50%m4",
   database: "winible",
@@ -37,3 +37,7 @@ export default new Sequelize({
     },
   },
 });
+
+sequelize.sync({ force: true });
+
+export default sequelize;

package/typed-model/{premium-content.ts → post.ts}

@@ -8,42 +8,39 @@ import {
   NOW,
   NonAttribute,
 } from "sequelize";
-import Media from "./media";
 
 import sequelize from "./pb-sequelize";
-import PhoneOwner from "./phone-owner";
-import PurchasedContent from "./purchased-content";
+import User from "./user";
+import Media from "./media";
 import ContentLike from "./content-like";
 
 // order of InferAttributes & InferCreationAttributes is important.
-class PremiumContent extends Model<
-  InferAttributes<PremiumContent>,
-  InferCreationAttributes<PremiumContent>
-> {
+class Post extends Model<InferAttributes<Post>, InferCreationAttributes<Post>> {
   // '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 amountInCents?: number;
+  declare userId: string;
+  declare url: string;
   declare name?: string;
   declare description?: string;
   declare isArchived?: boolean;
   declare likeCount?: number;
+  declare viewCount?: number;
   declare postDate?: Date;
   declare subLocked: boolean;
   declare isPpv: boolean;
   declare isPinned: boolean;
+  declare ppvAmountInCents?: number;
+  declare expiresIn?: Date;
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
-  static getByOwnerId: (ownerId: string) => Promise<PremiumContent | null>;
-  static getById: (id: string) => Promise<PremiumContent | null>;
-
-  // declare phone_owner?: NonAttribute<PhoneOwner>;
-  declare purchased_contents?: NonAttribute<PurchasedContent[]>;
   declare media?: NonAttribute<Media[]>;
+
+  static getByUserId: (ownerId: string) => Promise<Post | null>;
+  static getById: (id: string) => Promise<Post | null>;
 }
 
-PremiumContent.init(
+Post.init(
   {
     id: {
       type: DataTypes.BIGINT,
@@ -51,16 +48,20 @@ PremiumContent.init(
       allowNull: false,
       defaultValue: fn("next_id"),
     },
-    ownerId: {
+    userId: {
       type: DataTypes.BIGINT,
       allowNull: false,
-      field: "owner_id",
+      field: "user_id",
     },
-    amountInCents: {
+    ppvAmountInCents: {
       type: DataTypes.INTEGER,
-      field: "amount_in_cents",
+      field: "ppv_amount_in_cents",
       defaultValue: 0,
     },
+    url: {
+      type: DataTypes.STRING,
+      field: "url",
+    },
     name: {
       type: DataTypes.STRING,
       field: "name",
@@ -78,6 +79,10 @@ PremiumContent.init(
       type: DataTypes.INTEGER,
       field: "like_count",
     },
+    viewCount: {
+      type: DataTypes.INTEGER,
+      field: "view_count",
+    },
     postDate: {
       type: DataTypes.DATE,
       field: "post_date",
@@ -98,6 +103,7 @@ PremiumContent.init(
       field: "is_pinned",
       defaultValue: false,
     },
+    expiresIn: DataTypes.DATE,
     createdAt: DataTypes.DATE,
     updatedAt: DataTypes.DATE,
   },
@@ -113,52 +119,48 @@ Class functions
 ====================================================================
 */
 
-PremiumContent.getById = async (id: string) => {
-  return await PremiumContent.findOne({
+Post.getById = async (id: string) => {
+  return await Post.findOne({
     where: {
       id,
     },
   });
 };
 
-PremiumContent.getByOwnerId = async (ownerId: string) => {
-  return await PremiumContent.findOne({
+Post.getByUserId = async (userId: string) => {
+  return await Post.findOne({
     where: {
-      ownerId,
+      userId,
     },
   });
 };
 
-PremiumContent.hasMany(PurchasedContent, {
-  foreignKey: "content_id",
-  onDelete: "NO ACTION",
-  constraints: false,
-});
-PurchasedContent.belongsTo(PremiumContent, {
-  foreignKey: "content_id",
-  onDelete: "NO ACTION",
-  constraints: false,
+Post.hasOne(User, {
+  foreignKey: "id",
+  sourceKey: "userId",
 });
 
-Media.hasOne(PremiumContent, {
+Media.hasOne(Post, {
   foreignKey: "id",
-  sourceKey: "premiumContentId",
+  sourceKey: "postId",
 });
-PremiumContent.hasMany(Media, {
-  foreignKey: "premium_content_id",
+
+Post.hasMany(Media, {
+  foreignKey: "postId",
   sourceKey: "id",
 });
 
-PremiumContent.hasMany(ContentLike, {
-  foreignKey: "content_id",
+Post.hasMany(ContentLike, {
+  foreignKey: "postId",
   onDelete: "NO ACTION",
   constraints: false,
 });
-ContentLike.hasOne(PremiumContent, {
+
+ContentLike.hasOne(Post, {
   foreignKey: "id",
-  sourceKey: "content_id",
+  sourceKey: "postId",
   onDelete: "NO ACTION",
   constraints: false,
 });
 
-export default PremiumContent;
+export default Post;

package/typed-model/{purchased-content.ts → posts-on-users.ts}

@@ -9,29 +9,27 @@ import {
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";
-import PremiumContent from "./premium-content";
+import PremiumContent from "./post";
 import Notification from "./notification";
+import User from "./user";
 
 // order of InferAttributes & InferCreationAttributes is important.
-class PurchasedContent extends Model<
-  InferAttributes<PurchasedContent>,
-  InferCreationAttributes<PurchasedContent>
+class PostsOnUsers extends Model<
+  InferAttributes<PostsOnUsers>,
+  InferCreationAttributes<PostsOnUsers>
 > {
   // '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 contentId: string;
+  declare postId: number;
   declare createdAt: CreationOptional<Date>;
   declare updatedAt: CreationOptional<Date>;
-  static getById: (id: string) => Promise<PurchasedContent | null>;
-  static getPurchasedContentByUserFromOwner: (
-    userId: string,
-    ownerId: string
-  ) => Promise<PurchasedContent>;
+  static getById: (id: string) => Promise<PostsOnUsers | null>;
+  static getPostByUserId: (userId: string) => Promise<PostsOnUsers>;
 }
 
-PurchasedContent.init(
+PostsOnUsers.init(
   {
     id: {
       type: DataTypes.BIGINT,
@@ -44,16 +42,16 @@ PurchasedContent.init(
       allowNull: false,
       field: "user_id",
     },
-    contentId: {
+    postId: {
       type: DataTypes.BIGINT,
       allowNull: false,
-      field: "content_id",
+      field: "post_id",
     },
     createdAt: DataTypes.DATE,
     updatedAt: DataTypes.DATE,
   },
   {
-    tableName: "purchased_contents",
+    tableName: "posts_on_users",
     sequelize,
   }
 );
@@ -64,19 +62,16 @@ Class functions
 ====================================================================
 */
 
-PurchasedContent.getById = async (id: string) => {
-  return await PurchasedContent.findOne({
+PostsOnUsers.getById = async (id: string) => {
+  return await PostsOnUsers.findOne({
     where: {
       id,
     },
   });
 };
 
-PurchasedContent.getPurchasedContentByUserFromOwner = async (
-  userId: string,
-  ownerId: string
-) => {
-  let response = await PurchasedContent.findAll({
+PostsOnUsers.getPostByUserId = async (userId: string) => {
+  let response = await PostsOnUsers.findAll({
     where: {
       userId,
     },
@@ -84,17 +79,43 @@ PurchasedContent.getPurchasedContentByUserFromOwner = async (
       {
         model: PremiumContent,
         required: true,
-        where: { ownerId },
+        where: { userId },
       },
     ],
   });
   return response && response[0];
 };
 
-Notification.hasOne(PurchasedContent, {
+PremiumContent.hasMany(PostsOnUsers, {
+  foreignKey: "postId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+PostsOnUsers.hasOne(PremiumContent, {
+  foreignKey: "id",
+  sourceKey: "postId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+User.hasMany(PostsOnUsers, {
+  foreignKey: "userId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+PostsOnUsers.hasOne(User, {
+  foreignKey: "id",
+  sourceKey: "userId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+Notification.hasOne(PostsOnUsers, {
   foreignKey: "id",
-  sourceKey: "purchasedContentId",
+  sourceKey: "purchasedPostId",
   constraints: false,
 });
 
-export default PurchasedContent;
+export default PostsOnUsers;

package/typed-model/recurly-account.ts

@@ -4,7 +4,6 @@ import {
   InferCreationAttributes,
   CreationOptional,
   DataTypes,
-  fn,
 } from "sequelize";
 
 import sequelize from "./pb-sequelize";

package/typed-model/subscription-plan-on-post.ts

@@ -0,0 +1,77 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+} from "sequelize";
+import { Post, SubscriptionPlan } from ".";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class SubscriptionPlanOnPost extends Model<
+  InferAttributes<SubscriptionPlanOnPost>,
+  InferCreationAttributes<SubscriptionPlanOnPost>
+> {
+  // '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 postId: string;
+  declare subscriptionPlanId: string;
+
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+SubscriptionPlanOnPost.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    postId: {
+      type: DataTypes.BIGINT,
+      field: "post_id",
+    },
+    subscriptionPlanId: {
+      type: DataTypes.BIGINT,
+      field: "subscription_plan_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    sequelize,
+    tableName: "subscription_plan_on_post",
+  }
+);
+
+Post.hasMany(SubscriptionPlanOnPost, {
+  foreignKey: "postId",
+  sourceKey: "id",
+});
+
+SubscriptionPlanOnPost.hasOne(Post, {
+  foreignKey: "id",
+  sourceKey: "postId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+SubscriptionPlan.hasMany(SubscriptionPlanOnPost, {
+  foreignKey: "subscriptionPlanId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+SubscriptionPlanOnPost.hasOne(SubscriptionPlan, {
+  foreignKey: "id",
+  sourceKey: "subscriptionPlanId",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+export default SubscriptionPlanOnPost;