models.txt

const { Model, Validator } = require('sequelize');
const bcrypt = require('bcryptjs');

module.exports = (sequelize, DataTypes) => {
  class User extends Model {
    toSafeObject() {
      const { id, username, email } = this; // context will be the User instance
      return { id, username, email };
    }

    validatePassword(password) {
      return bcrypt.compareSync(password, this.hashedPassword.toString());
    }

    static getCurrentUserById(id) {
      return User.scope("currentUser").findByPk(id);
    }

    static async login({ credential, password }) {
      const { Op } = require('sequelize');
      const user = await User.scope('loginUser').findOne({
        where: {
          [Op.or]: {
            username: credential,
            email: credential
          }
        }
      });

      if (user && user.validatePassword(password)) {
        return await User.scope('currentUser').findByPk(user.id);
      }
    }

    static async signup({ username, email, password }) {
      const hashedPassword = bcrypt.hashSync(password);
      const user = await User.create({
        username,
        email,
        hashedPassword
      });
      return await User.scope('currentUser').findByPk(user.id);
    }

    static associate(models) {
      User.hasMany(models.Notebook, {
        foreignKey: "authorId",
        onDelete: "CASCADE",
        hooks: true
      });

      User.hasMany(models.ImageNotebook, {
        foreignKey: "authorId",
        onDelete: "CASCADE",
        hooks: true
      });

      User.hasMany(models.TextNote, {
        foreignKey: "authorId",
        onDelete: "CASCADE",
        hooks: true
      });

      User.hasMany(models.ImageNote, {
        foreignKey: "authorId",
        onDelete: "CASCADE",
        hooks: true
      })
    }};

  User.init(
    {
      username: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true,
        validate: {
          len: [4, 30],
          isNotEmail(value) {
            if (Validator.isEmail(value)) {
              throw new Error("Cannot be an email.");
      }}}},

      email: {
        type: DataTypes.STRING,
        allowNull: false,
        unique: true,
        validate: {
          len: [3, 256],
          isEmail: true
      }},
      hashedPassword: {
        type: DataTypes.STRING.BINARY,
        allowNull: false,
        validate: {
          len: [60, 60]
      }}},

    {
      sequelize,
      modelName: "User",
      defaultScope: {
        attributes: {
          exclude: ["hashedPassword", "email", "createdAt", "updatedAt"]
        }
      },
      scopes: {
        currentUser: {
          attributes: { exclude: ["hashedPassword"] }
        },
        loginUser: {
          attributes: {}
      }}});

  return User;
};






'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Notebook extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {

      Notebook.hasMany(models.TextNote, {
        foreignKey: "notebookId",
        onDelete: "CASCADE",
        hooks: true
      })

      Notebook.belongsTo(models.User, {
        foreignKey: "authorId"
      });
    }
  }
  Notebook.init({
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    authorId:  {
      type: DataTypes.INTEGER,
      allowNull: false
    },
    name: {
      type: DataTypes.STRING(60),
      allowNull: false
    }
  }, {
    sequelize,
    modelName: 'Notebook',
  });
  return Notebook;
};





'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class ImageNotebook extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {

      ImageNotebook.hasMany(models.ImageNote, {
        foreignKey: "notebookId",
        onDelete: "CASCADE",
        hooks: true
      });

      ImageNotebook.belongsTo(models.User, {
        foreignKey: "authorId"
      });
  }};

  ImageNotebook.init({
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    authorId: {
      type: DataTypes.INTEGER,
      allowNull: false
    },
    name: {
      type: DataTypes.STRING(60),
      allowNull: false
    }
  }, {
    sequelize,
    modelName: 'ImageNotebook',
  });
  return ImageNotebook;
};




'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class TextNote extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      TextNote.belongsTo(models.User, {
        foreignKey: "authorId"
      });

      TextNote.belongsTo(models.Notebook, {
        foreignKey: "notebookId"
      });
  }};

  TextNote.init({
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true,
      unique: true
    },
    authorId:{
      type: DataTypes.INTEGER,
      allowNull: false,
      foreignKey: true
    },
    notebookId : {
      type: DataTypes.INTEGER,
      allowNull: true,
      foreignKey: true
    },
    name: {
      type: DataTypes.STRING(60),
      allowNull: false
    },
      note: {
        type: DataTypes.STRING(2000),
        allowNull: false
  }},
  {
    sequelize,
    modelName: 'TextNote',
  });
  return TextNote;
};




'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class ImageNote extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      ImageNote.belongsTo(models.User, {
        foreignKey: "authorId"
      });

      ImageNote.belongsTo(models.Notebook, {
        foreignKey: "notebookId"
      });
  }}

  ImageNote.init({
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true,
      unique: true
    },
    authorId: {
      type: DataTypes.INTEGER,
      allowNull: false,
      foreignKey: true
    },
    notebookId: {
      type: DataTypes.INTEGER,
      allowNull: true,
      foreignKey: true
    },
    name: {
      type: DataTypes.STRING(60),
      allowNull: false
    },
    url: {
      type: DataTypes.STRING(255),
      allowNull: false
  }},
  {
    sequelize,
    modelName: 'ImageNote',
  });
  return ImageNote;
};



'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Pal extends Model {
    static associate(models) {
      Pal.belongsTo(models.User, {
        foreignKey: "palOne",
        as: "palOneUser"
      });

      Pal.belongsTo(models.User, {
        foreignKey: "palTwo",
        as: "palTwoUser"
      });
    }
  }
  Pal.init({
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    palOne: {
      type: DataTypes.INTEGER,
      allowNull: false,
      references: {
        model: 'Users',
        key: 'id'
      }
    },
    palTwo: {
      type: DataTypes.INTEGER,
      allowNull: false,
      references: {
        model: 'Users',
        key: 'id'
      }
    }
  }, {
    sequelize,
    modelName: 'Pal',
  });
  return Pal;
};


'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Collaboration extends Model {
    static associate(models) {
      Collaboration.belongsTo(models.User, {
        foreignKey: "authorId"
      });

      Collaboration.belongsTo(models.User, {
        foreignKey: "collaboratorId"
      });

      Collaboration.belongsTo(models.TextNote, {
        foreignKey: "noteId"
      });
    }
  }
  Collaboration.init({
    id: {
      type: DataTypes.INTEGER,
      autoIncrement: true,
      primaryKey: true
    },
    authorId: {
      type: DataTypes.INTEGER,
      allowNull: false
    },
    collaboratorId: {
      type: DataTypes.INTEGER,
      allowNull: false
    },
    noteId: {
      type: DataTypes.INTEGER,
      allowNull: false
    },
    textNote: {
      type: DataTypes.BOOLEAN,
      allowNull: false
    }
  }, {
    sequelize,
    modelName: 'Collaboration',
  });
  return Collaboration;
};



'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Post extends Model {
    /**
     * Helper method for defining associations.
     * This method is not a part of Sequelize lifecycle.
     * The `models/index` file will call this method automatically.
     */
    static associate(models) {
      Post.belongsTo(models.User, {
        foreignKey: 'authorId'
      });

      if (this.textNote) {
        Post.belongsTo(models.TextNote, {
          foreignKey: 'noteId'
        });
      } else {
        Post.belongsTo(models.ImageNote, {
          foreignKey: 'noteId'
        });
      }
    }
  }
  Post.init({
    authorId: {
      type: DataTypes.INTEGER,
      allowNull: false,
      references: {
        model: 'Users',
        key: 'id'
      },
      onUpdate: 'CASCADE',
      onDelete: 'CASCADE'
    },
    noteId: {
      type: DataTypes.INTEGER,
      allowNull: false,
      references: {
        model: 'Notes',
        key: 'id'
      },
      onUpdate: 'CASCADE',
      onDelete: 'CASCADE'
    },
    textNote: {
      type: DataTypes.BOOLEAN,
      allowNull: false
    },
    caption: {
      type: DataTypes.STRING,
      allowNull: false
    }
  }, {
    sequelize,
    modelName: 'Post',
  });
  return Post;
};






'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Reaction extends Model {
    static associate(models) {
      Reaction.belongsTo(models.User, { foreignKey: 'userId', as: 'user' });
      Reaction.belongsTo(models.User, { foreignKey: 'authorId', as: 'author' });
      Reaction.belongsTo(models.Post, { foreignKey: 'postId', as: 'post' });
    }
  }
  Reaction.init({
    userId: {
      type: DataTypes.INTEGER,
      allowNull: false,
    },
    authorId: {
      type: DataTypes.INTEGER,
      allowNull: false,
    },
    postId: {
      type: DataTypes.INTEGER,
      allowNull: false,
    },
    reactionType: {
      type: DataTypes.STRING,
      allowNull: false,
      validate: {
        notNull: true,
        isIn: [['like', 'dislike']],
      }
    }
  }, {
    sequelize,
    modelName: 'Reaction',
  });
  return Reaction;
};


'use strict';
const { Model } = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Comment extends Model {
    static associate(models) {
      Comment.belongsTo(models.User, { foreignKey: 'authorId' });
      Comment.belongsTo(models.Post, { foreignKey: 'postId' });
      Comment.belongsTo(models.Comment, { foreignKey: 'parentCommentId' });
      Comment.hasMany(models.Comment, { foreignKey: 'parentCommentId' });
    }
  }

  Comment.init(
    {
      authorId: {
        type: DataTypes.INTEGER,
        allowNull: false,
        references: {
          model: 'Users',
          key: 'id'
        },
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE'
      },
      postId: {
        type: DataTypes.INTEGER,
        allowNull: false,
        references: {
          model: 'Posts',
          key: 'id'
        },
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE'
      },
      parentCommentId: {
        type: DataTypes.INTEGER,
        allowNull: true,
        references: {
          model: 'Comments',
          key: 'id'
        },
        onUpdate: 'CASCADE',
        onDelete: 'CASCADE'
      },
      content: {
        type: DataTypes.STRING,
        allowNull: false
      }
    },
    {
      sequelize,
      modelName: 'Comment'
    }
  );

  return Comment;
};