@winible/winible-typed 1.0.0

package/typed-model/purchased-content.ts

@@ -0,0 +1,100 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+  NOW,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import PremiumContent from "./premium-content";
+import Notification from "./notification";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class PurchasedContent extends Model<
+  InferAttributes<PurchasedContent>,
+  InferCreationAttributes<PurchasedContent>
+> {
+  // '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 createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+  static getById: (id: string) => Promise<PurchasedContent | null>;
+  static getPurchasedContentByUserFromOwner: (
+    userId: string,
+    ownerId: string
+  ) => Promise<PurchasedContent>;
+}
+
+PurchasedContent.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    userId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "user_id",
+    },
+    contentId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "content_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "purchased_contents",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+PurchasedContent.getById = async (id: string) => {
+  return await PurchasedContent.findOne({
+    where: {
+      id,
+    },
+  });
+};
+
+PurchasedContent.getPurchasedContentByUserFromOwner = async (
+  userId: string,
+  ownerId: string
+) => {
+  let response = await PurchasedContent.findAll({
+    where: {
+      userId,
+    },
+    include: [
+      {
+        model: PremiumContent,
+        required: true,
+        where: { ownerId },
+      },
+    ],
+  });
+  return response && response[0];
+};
+
+Notification.hasOne(PurchasedContent, {
+  foreignKey: "id",
+  sourceKey: "purchasedContentId",
+  constraints: false,
+});
+
+export default PurchasedContent;

package/typed-model/short-url.ts

@@ -0,0 +1,120 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class ShortUrl extends Model<
+  InferAttributes<ShortUrl>,
+  InferCreationAttributes<ShortUrl>
+> {
+  // '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 shortCode: string;
+  declare longUrl: string;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+  static createShortUrl: (longUrl: string) => Promise<string>;
+  static customShortUrl: (
+    longUrl: string,
+    shortCode: string
+  ) => Promise<string>;
+  static getByShortCode: (shortCode: string) => Promise<ShortUrl | null>;
+}
+
+ShortUrl.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    shortCode: {
+      type: DataTypes.STRING,
+      allowNull: false,
+      field: "short_code",
+      unique: true,
+    },
+    longUrl: {
+      type: DataTypes.STRING(500),
+      allowNull: false,
+      field: "long_url",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    // Other model options go here
+    tableName: "short_urls",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+function randomString(length: number, chars: string) {
+  var result = "";
+  for (var i = length; i > 0; --i)
+    result += chars[Math.floor(Math.random() * chars.length)];
+  return result;
+}
+
+ShortUrl.createShortUrl = async (longUrl: string) => {
+  const shortCode = randomString(
+    7,
+    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  );
+
+  if (!process.env.SHORT_URL) {
+    return longUrl;
+  }
+
+  try {
+    await ShortUrl.create({
+      shortCode,
+      longUrl,
+    });
+    return process.env.SHORT_URL + shortCode;
+  } catch (err) {
+    console.log(err);
+    return longUrl;
+  }
+};
+
+ShortUrl.customShortUrl = async (longUrl: string, shortCode: string) => {
+  if (!process.env.SHORT_URL) {
+    return longUrl;
+  }
+
+  try {
+    await ShortUrl.create({
+      shortCode,
+      longUrl,
+    });
+    return process.env.SHORT_URL + shortCode;
+  } catch (err) {
+    console.log(err);
+    return longUrl;
+  }
+};
+
+ShortUrl.getByShortCode = async (shortCode: string) => {
+  return await ShortUrl.findOne({
+    where: {
+      shortCode,
+    },
+  });
+};
+export default ShortUrl;

package/typed-model/subscription-bundle.ts

@@ -0,0 +1,75 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+  NOW,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import SubscriptionPlan from "./subscription-plan";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class SubscriptionBundle extends Model<
+  InferAttributes<SubscriptionBundle>,
+  InferCreationAttributes<SubscriptionBundle>
+> {
+  // '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 subscriptionPlanId: string;
+  declare bundleIntervalCount?: number;
+  declare bundleDiscountPercentage?: number;
+  declare isActive?: boolean;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+SubscriptionBundle.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    subscriptionPlanId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "subscription_plan_id",
+    },
+    bundleIntervalCount: {
+      type: DataTypes.INTEGER,
+      field: "bundle_interval_count",
+      defaultValue: 0,
+    },
+    bundleDiscountPercentage: {
+      type: DataTypes.FLOAT,
+      field: "bundle_discount_percentage",
+    },
+    isActive: {
+      type: DataTypes.BOOLEAN,
+      field: "is_active",
+      defaultValue: true,
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "subscription_bundles",
+    sequelize,
+  }
+);
+
+SubscriptionBundle.hasOne(SubscriptionPlan, {
+  foreignKey: "id",
+  sourceKey: "subscriptionPlanId",
+});
+SubscriptionPlan.hasMany(SubscriptionBundle, {
+  foreignKey: "subscription_plan_id",
+  sourceKey: "id",
+});
+
+export default SubscriptionBundle;

package/typed-model/subscription-category-tags.ts

@@ -0,0 +1,79 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+import { SubscriptionPlan } from ".";
+import CategoryTag from "./category-tag";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class SubscriptionCategoryTag extends Model<
+  InferAttributes<SubscriptionCategoryTag>,
+  InferCreationAttributes<SubscriptionCategoryTag>
+> {
+  // '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 subscriptionPlanId: string;
+  declare tagId: string;
+
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+SubscriptionCategoryTag.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    subscriptionPlanId: {
+      type: DataTypes.BIGINT,
+      field: "subscription_plan_id",
+    },
+    tagId: {
+      type: DataTypes.BIGINT,
+      field: "tag_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    sequelize,
+    tableName: "subscription_category_tags",
+    // Other model options go here
+  }
+);
+
+CategoryTag.hasMany(SubscriptionCategoryTag, {
+  foreignKey: "tag_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+SubscriptionCategoryTag.hasOne(CategoryTag, {
+  foreignKey: "id",
+  sourceKey: "tag_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+SubscriptionPlan.hasMany(SubscriptionCategoryTag, {
+  foreignKey: "subscription_plan_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+SubscriptionCategoryTag.hasOne(SubscriptionPlan, {
+  foreignKey: "id",
+  sourceKey: "subscription_plan_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+export default SubscriptionCategoryTag;

package/typed-model/subscription-plan.ts

@@ -0,0 +1,171 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+  NOW,
+  NonAttribute,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import PhoneOwner from "./phone-owner";
+import Subscription from "./subscription";
+import SubscriptionPromotion from "./subscription-promotion";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class SubscriptionPlan extends Model<
+  InferAttributes<SubscriptionPlan>,
+  InferCreationAttributes<SubscriptionPlan>
+> {
+  // '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 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 oneTimePurchase?: boolean;
+  declare accessEndDate?: Date;
+  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>;
+
+  declare subscriptions?: NonAttribute<Subscription[]>;
+  declare SubscriptionPromotions?: NonAttribute<any[]>;
+  declare SubscriptionBundles?: NonAttribute<any[]>;
+}
+
+SubscriptionPlan.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    ownerId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "owner_id",
+    },
+    planName: {
+      type: DataTypes.STRING,
+      field: "plan_name",
+    },
+    amountInCents: {
+      type: DataTypes.INTEGER,
+      field: "amount_in_cents",
+    },
+    intervalCount: {
+      type: DataTypes.INTEGER,
+      field: "interval_count",
+      defaultValue: 1,
+    },
+    intervalUnit: {
+      type: DataTypes.STRING,
+      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",
+    },
+    oneTimePurchase: {
+      type: DataTypes.BOOLEAN,
+      field: "one_time_purchase",
+      defaultValue: false,
+    },
+    accessEndDate: {
+      type: DataTypes.DATE,
+      field: "access_end_date",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "subscription_plans",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+SubscriptionPlan.getById = async (id: string) => {
+  return await SubscriptionPlan.findOne({
+    where: {
+      id,
+    },
+  });
+};
+
+SubscriptionPlan.getByOwnerId = async (ownerId: string) => {
+  return await SubscriptionPlan.findOne({
+    where: {
+      ownerId,
+    },
+  });
+};
+
+SubscriptionPlan.getByPaypalPlanId = async (paypalPlanId: string) => {
+  return await SubscriptionPlan.findOne({
+    where: {
+      paypalPlanId,
+    },
+  });
+};
+
+SubscriptionPlan.hasMany(Subscription, { foreignKey: "subscription_plan_id" });
+Subscription.hasOne(SubscriptionPlan, {
+  foreignKey: "id",
+  sourceKey: "subscription_plan_id",
+});
+
+SubscriptionPlan.hasOne(PhoneOwner, {
+  foreignKey: "id",
+  sourceKey: "ownerId",
+});
+PhoneOwner.hasMany(SubscriptionPlan, {
+  foreignKey: "owner_id",
+  sourceKey: "id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+SubscriptionPromotion.hasOne(SubscriptionPlan, {
+  foreignKey: "id",
+  sourceKey: "subscriptionPlanId",
+});
+SubscriptionPlan.hasMany(SubscriptionPromotion, {
+  foreignKey: "subscription_plan_id",
+  sourceKey: "id",
+});
+
+export default SubscriptionPlan;

package/typed-model/subscription-promotion.ts

@@ -0,0 +1,125 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+  NOW,
+  Op,
+  col,
+  WhereOptions,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class SubscriptionPromotion extends Model<
+  InferAttributes<SubscriptionPromotion>,
+  InferCreationAttributes<SubscriptionPromotion>
+> {
+  // '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 subscriptionPlanId: string;
+  declare title?: string;
+  declare trialIntervalCount?: number;
+  declare trialDiscountPercentage?: number;
+  declare trialLength?: number;
+  declare saleEndDate?: Date;
+  declare neverExpire?: boolean;
+  declare hasClaimLimit?: boolean;
+  declare claimLimit?: number;
+  declare numClaims?: number;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+  static activeWhereClause: () => WhereOptions<any>;
+}
+
+SubscriptionPromotion.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    subscriptionPlanId: {
+      type: DataTypes.BIGINT,
+      allowNull: false,
+      field: "subscription_plan_id",
+    },
+    title: {
+      type: DataTypes.STRING,
+      field: "title",
+    },
+    trialIntervalCount: {
+      type: DataTypes.INTEGER,
+      field: "trial_interval_count",
+      defaultValue: 0,
+    },
+    trialDiscountPercentage: {
+      type: DataTypes.FLOAT,
+      field: "trial_discount_percentage",
+    },
+    trialLength: {
+      type: DataTypes.INTEGER,
+      field: "trial_length",
+      defaultValue: 0,
+    },
+    saleEndDate: {
+      type: DataTypes.DATE,
+      field: "sale_end_date",
+    },
+    neverExpire: {
+      type: DataTypes.BOOLEAN,
+      field: "never_expire",
+      defaultValue: false,
+    },
+    hasClaimLimit: {
+      type: DataTypes.BOOLEAN,
+      field: "has_claim_limit",
+      defaultValue: false,
+    },
+    claimLimit: {
+      type: DataTypes.INTEGER,
+      field: "claim_limit",
+    },
+    numClaims: {
+      type: DataTypes.INTEGER,
+      field: "num_claims",
+      defaultValue: 0,
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "subscription_promotions",
+    sequelize,
+  }
+);
+
+SubscriptionPromotion.activeWhereClause = () => {
+  return {
+    [Op.and]: [
+      {
+        [Op.or]: {
+          neverExpire: true,
+          saleEndDate: {
+            [Op.gte]: new Date(),
+          },
+        },
+      },
+      {
+        [Op.or]: {
+          hasClaimLimit: false,
+          numClaims: {
+            [Op.lt]: col("claim_limit"),
+          },
+        },
+      },
+    ],
+  };
+};
+
+export default SubscriptionPromotion;