outline/server/models/Document.js

import slug from 'slug';
import _ from 'lodash';
import randomstring from 'randomstring';
import {
  DataTypes,
  sequelize,
} from '../sequelize';
import {
  convertToMarkdown,
} from '../../frontend/utils/markdown';
import {
  truncateMarkdown,
} from '../utils/truncate';
import User from './User';
import Revision from './Revision';

slug.defaults.mode = 'rfc3986';

const createRevision = async (doc) => {
  // Create revision of the current (latest)
  await Revision.create({
    title: doc.title,
    text: doc.text,
    html: doc.html,
    preview: doc.preview,
    userId: doc.lastModifiedById,
    documentId: doc.id,
  });
};

const documentBeforeSave = async (doc) => {
  doc.html = convertToMarkdown(doc.text);
  doc.preview = truncateMarkdown(doc.text, 160);

  doc.revisionCount = doc.revisionCount + 1;

  // Collaborators
  let ids = [];
  // Only get previous user IDs if the document already exists
  if (doc.id) {
    ids = await Revision.findAll({
      attributes: [[DataTypes.literal('DISTINCT "userId"'), 'userId']],
      where: {
        documentId: doc.id,
      },
    }).map(rev => rev.userId);
  }
  // We'll add the current user as revision hasn't been generated yet
  ids.push(doc.lastModifiedById);
  doc.collaboratorIds = _.uniq(ids);

  return doc;
};

const Document = sequelize.define('document', {
  id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true },
  urlId: { type: DataTypes.STRING, primaryKey: true },
  private: { type: DataTypes.BOOLEAN, defaultValue: true },
  title: DataTypes.STRING,
  text: DataTypes.TEXT,
  html: DataTypes.TEXT,
  preview: DataTypes.TEXT,
  revisionCount: { type: DataTypes.INTEGER, defaultValue: 0 },

  parentDocumentId: DataTypes.UUID,
  createdById: {
    type: DataTypes.UUID,
    allowNull: false,
    references: {
      model: 'users',
    },
  },
  lastModifiedById: {
    type: DataTypes.UUID,
    allowNull: false,
    references: {
      model: 'users',
    },
  },
  collaboratorIds: DataTypes.ARRAY(DataTypes.UUID),
}, {
  paranoid: true,
  hooks: {
    beforeValidate: (doc) => {
      doc.urlId = doc.urlId || randomstring.generate(10);
    },
    beforeCreate: documentBeforeSave,
    beforeUpdate: documentBeforeSave,
    afterCreate: async (doc) => await createRevision(doc),
    afterUpdate: async (doc) => await createRevision(doc),
  },
  instanceMethods: {
    getUrl() {
      const slugifiedTitle = slug(this.title);
      return `/d/${slugifiedTitle}-${this.urlId}`;
    },
  },
});

Document.belongsTo(User);

Document.searchForUser = async (user, query, options = {}) => {
  const limit = options.limit || 15;
  const offset = options.offset || 0;

  const sql = `
  SELECT * FROM documents
  WHERE "searchVector" @@ plainto_tsquery('english', :query) AND
    "teamId" = '${user.teamId}'::uuid AND
    "deletedAt" IS NULL
  ORDER BY ts_rank(documents."searchVector", plainto_tsquery('english', :query)) DESC
  LIMIT :limit OFFSET :offset;
  `;

  const documents = await sequelize
  .query(
    sql,
    {
      replacements: {
        query,
        limit,
        offset,
      },
      model: Document,
    }
  );

  return documents;
};

export default Document;