codimd/lib/note/service.js

const { Note, ArchivedNoteAlias, sequelize } = require('../models');
const realtime = require('../realtime/realtime');

const forbiddenAlias = ['', 'new', 'me', 'history', '403', '404', '500', 'config'];
const sanitize = (alias) => {
  return alias.replace(/( |\/)/, '');
}

const asyncGetNote = async (originAliasOrNoteId) => {
  const noteId = await Note.parseNoteIdAsync(originAliasOrNoteId);
  const note = await Note.findOne({
    where: {
      id: noteId
    }
  })
  if (!note) {
    throw Error('Can\'t find the note.');
  }
  return note;
}

const asyncGetNoteIdForAliasConflict = async (alias) => {
  const sanitizedAlias = sanitize(alias);
  const p1 = Note.findOne({
    where: {
      alias: sanitizedAlias
    }
  });
  const p2 = ArchivedNoteAlias.findOne({
    where: {
      alias: sanitizedAlias
    }
  });
  const [conflictNote, conflictAarchivedAlias] = await Promise.all([p1, p2]);

  if (conflictNote) {
    return conflictNote.id
  }
  if (conflictAarchivedAlias) {
    return conflictAarchivedAlias.noteId
  }
  return null;
}

const asyncCheckAliasValid = async (originAliasOrNoteId, alias) => {
  const sanitizedAlias = sanitize(alias);
  if (forbiddenAlias.indexOf(sanitizedAlias) > -1) {
    return false;
  }

  const conflictNoteId = await asyncGetNoteIdForAliasConflict(alias)
    .catch((err) => { throw err });

  const note = await asyncGetNote(originAliasOrNoteId)
    .catch((err) => { throw err });

  return !conflictNoteId || conflictNoteId === note.id;
}

const asyncUpdateAlias = async (originAliasOrNoteId, alias) => {
  const sanitizedAlias = sanitize(alias);
  const note = await asyncGetNote(originAliasOrNoteId)
    .catch((err) => { throw err });

  const t = await sequelize.transaction();
  if (note.alias) {
    const archivedAlias = await ArchivedNoteAlias.findOne({
      where: {
        alias: note.alias,
      }
    })
      .catch(async err => { throw err })
    if (!archivedAlias) {
      await ArchivedNoteAlias.create({
        noteId: note.id,
        alias: note.alias
      }, { transaction: t })
        .catch(async err => {
          await t.rollback();
          throw Error('Add archived note alias failed. ' + err.message);
        })
    }
  }

  const updatedNote = await note.update({
    alias: sanitizedAlias,
    lastchangeAt: Date.now()
  }, { transaction: t })
    .catch(async err => {
      await t.rollback();
      throw Error('Write note content error. ' + err.message);
    })

  await t.commit();

  realtime.io.to(updatedNote.id)
    .emit('alias updated', {
      alias: updatedNote.alias
    });

  return true;
}

exports.sanitize = sanitize;
exports.asyncGetNote = asyncGetNote;
exports.asyncCheckAliasValid = asyncCheckAliasValid;
exports.asyncUpdateAlias = asyncUpdateAlias;