feat: can now archive application pages and restore them

Author: AntoineRelief

config/default.js

@@ -171,4 +171,7 @@ module.exports = {
  logger: {
  keep: true,
  },
+ archive: {
+ expires: 60 * 60 * 24 * 30, // Default archive time, in seconds. Set to 30 days
+ },
 };

src/models/dashboard.model.ts

@@ -19,6 +19,8 @@ export interface Dashboard extends Document {
  structure?: any;
  showFilter?: boolean;
  buttons?: Button[];
+ archived: boolean;
+ archivedAt?: Date;
 }
 
 /** Mongoose button schema declaration */
@@ -40,6 +42,14 @@ const dashboardSchema = new Schema<Dashboard>(
  structure: mongoose.Schema.Types.Mixed,
  showFilter: Boolean,
  buttons: [buttonSchema],
+ archived: {
+ type: Boolean,
+ default: false,
+ },
+ archivedAt: {
+ type: Date,
+ expires: 2592000,
+ },
  },
  {
  timestamps: { createdAt: 'createdAt', updatedAt: 'modifiedAt' },

src/models/page.model.ts

@@ -10,6 +10,7 @@ import { Workflow } from './workflow.model';
 import { Record } from './record.model';
 import { Resource } from './resource.model';
 import { ReferenceData } from './referenceData.model';
+import { has } from 'lodash';
 
 /** Interface for the page context */
 export type PageContextT = (
@@ -49,6 +50,8 @@ export interface Page extends Document {
  canDelete?: (mongoose.Types.ObjectId | Role)[];
  };
  visible: boolean;
+ archived: boolean;
+ archivedAt?: Date;
 }
 
 /** Mongoose page schema declaration */
@@ -109,12 +112,101 @@ const pageSchema = new Schema<Page>(
  type: Boolean,
  default: true,
  },
+ archived: {
+ type: Boolean,
+ default: false,
+ },
+ archivedAt: {
+ type: Date,
+ expires: 2592000,
+ },
  },
  {
  timestamps: { createdAt: 'createdAt', updatedAt: 'modifiedAt' },
  }
 );
 
+// We need to declare it like that, otherwise we cannot access the 'this'.
+pageSchema.pre(['updateOne', 'findOneAndUpdate'], async function () {
+ const update = this.getUpdate();
+ if (has(update, 'archived')) {
+ const page: Page = await this.clone().findOne();
+ switch (page.type) {
+ case contentType.workflow: {
+ const workflow = await Workflow.findById(page.content);
+ if (workflow) {
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ if (update['archived']) {
+ await workflow.updateOne({
+ archived: true,
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ archivedAt: update['archivedAt'],
+ });
+ } else {
+ await workflow.updateOne({
+ archived: false,
+ archivedAt: null,
+ });
+ }
+ }
+ break;
+ }
+ case contentType.dashboard: {
+ const dashboard = await Dashboard.findById(page.content);
+ if (dashboard) {
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ if (update['archived']) {
+ dashboard.archived = true;
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ dashboard.archivedAt = update['archivedAt'];
+ await dashboard.save();
+ } else {
+ dashboard.archived = false;
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ dashboard.archivedAt = null;
+ await dashboard.save();
+ }
+ }
+ if (page.contentWithContext) {
+ const dashboards: Dashboard[] = [];
+ page.contentWithContext.forEach((item: any) => {
+ if (item.content) {
+ dashboards.push(item.content);
+ }
+ });
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ if (update['archived']) {
+ await Dashboard.updateMany(
+ { _id: { $in: dashboards } },
+ {
+ $set: {
+ archived: true,
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ archivedAt: update['archivedAt'],
+ },
+ }
+ );
+ } else {
+ await Dashboard.updateMany(
+ { _id: { $in: dashboards } },
+ {
+ $set: {
+ archived: false,
+ archivedAt: null,
+ },
+ }
+ );
+ }
+ }
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ }
+});
+
 // handle cascading deletion and references deletion for pages
 addOnBeforeDeleteMany(pageSchema, async (pages) => {
  // CASCADE DELETION

src/models/step.model.ts

@@ -21,6 +21,8 @@ export interface Step extends Document {
  canSee?: any;
  canUpdate?: any;
  canDelete?: any;
+ archived: boolean;
+ archivedAt?: Date;
 }
 
 /** Mongoose step schema definition */
@@ -53,6 +55,14 @@ const stepSchema = new Schema<Step>(
  },
  ],
  },
+ archived: {
+ type: Boolean,
+ default: false,
+ },
+ archivedAt: {
+ type: Date,
+ expires: 2592000,
+ },
  },
  {
  timestamps: { createdAt: 'createdAt', updatedAt: 'modifiedAt' },

src/models/workflow.model.ts

@@ -2,6 +2,7 @@ import { AccessibleRecordModel, accessibleRecordsPlugin } from '@casl/mongoose';
 import mongoose, { Schema, Document } from 'mongoose';
 import { addOnBeforeDeleteMany } from '@utils/models/deletion';
 import { Step } from './step.model';
+import { has } from 'lodash';
 
 /** Workflow documents interface declaration */
 export interface Workflow extends Document {
@@ -10,6 +11,8 @@ export interface Workflow extends Document {
  createdAt: Date;
  modifiedAt: Date;
  steps: any[];
+ archived: boolean;
+ archivedAt?: Date;
 }
 
 /** Mongoose workflow schema declaration */
@@ -20,12 +23,57 @@ const workflowSchema = new Schema<Workflow>(
  type: [mongoose.Schema.Types.ObjectId],
  ref: 'Step',
  },
+ archived: {
+ type: Boolean,
+ default: false,
+ },
+ archivedAt: {
+ type: Date,
+ expires: 2592000,
+ },
  },
  {
  timestamps: { createdAt: 'createdAt', updatedAt: 'modifiedAt' },
  }
 );
 
+workflowSchema.pre('updateOne', async function () {
+ const update = this.getUpdate();
+ if (has(update, 'archived')) {
+ // Copy query to get workflow
+ const workflow: Workflow = await this.clone().findOne();
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ if (update['archived']) {
+ // Automatically archive related steps
+ await Step.updateMany(
+ {
+ _id: { $in: workflow.steps },
+ },
+ {
+ $set: {
+ archived: true,
+ // eslint-disable-next-line @typescript-eslint/dot-notation
+ archivedAt: update['archivedAt'],
+ },
+ }
+ );
+ } else {
+ // Automatically unarchive related steps
+ await Step.updateMany(
+ {
+ _id: { $in: workflow.steps },
+ },
+ {
+ $set: {
+ archived: false,
+ archivedAt: null,
+ },
+ }
+ );
+ }
+ }
+});
+
 // handle cascading deletion for workflows
 addOnBeforeDeleteMany(workflowSchema, async (workflows) => {
  const steps = workflows.reduce((acc, w) => acc.concat(w.steps), []);

src/schema/mutation/deletePage.mutation.ts

@@ -35,7 +35,16 @@ export default {
  }
 
  // delete page
- await page.deleteOne();
+ if (page.archived) {
+ // If archived, hard delete it
+ await page.deleteOne();
+ } else {
+ // Else, archive it
+ await page.updateOne({
+ archived: true,
+ archivedAt: new Date(),
+ });
+ }
  return page;
  } catch (err) {
  logger.error(err.message, { stack: err.stack });

src/schema/mutation/deleteRecords.mutation.ts

@@ -57,7 +57,9 @@ export default {
  } else {
  const result = await Record.updateMany(
  { _id: { $in: toDelete.map((x) => x._id) } },
- { archived: true },
+ {
+ $set: { archived: true },
+ },
  { new: true }
  );
  return result.modifiedCount;

src/schema/mutation/index.ts

@@ -84,6 +84,7 @@ import editLayer from './editLayer.mutation';
 import deleteLayer from './deleteLayer.mutation';
 import editPageContext from './editPageContext.mutation';
 import addDashboardWithContext from './addDashboardWithContext.mutation';
+import restorePage from './restorePage.mutation';
 
 /** GraphQL mutation definition */
 const Mutation = new GraphQLObjectType({
@@ -174,6 +175,7 @@ const Mutation = new GraphQLObjectType({
  addLayer,
  editLayer,
  deleteLayer,
+ restorePage,
  },
 });
 

src/schema/mutation/restorePage.mutation.ts

@@ -0,0 +1,57 @@
+import { GraphQLNonNull, GraphQLID, GraphQLError } from 'graphql';
+import { PageType } from '../types';
+import { Page } from '@models';
+import extendAbilityForPage from '@security/extendAbilityForPage';
+import { logger } from '@services/logger.service';
+
+/**
+ * Restore archived page.
+ * Page model should automatically restore associated content.
+ */
+export default {
+ type: PageType,
+ args: {
+ id: { type: new GraphQLNonNull(GraphQLID) },
+ },
+ async resolve(parent, args, context) {
+ try {
+ // Authentication check
+ const user = context.user;
+ if (!user)
+ throw new GraphQLError(
+ context.i18next.t('common.errors.userNotLogged')
+ );
+
+ // Find page
+ const page = await Page.findById(args.id);
+
+ // Check access
+ const ability = await extendAbilityForPage(user, page);
+ if (ability.cannot('update', page)) {
+ throw new GraphQLError(
+ context.i18next.t('common.errors.permissionNotGranted')
+ );
+ }
+
+ // restore page
+ if (page && page.archived) {
+ return await Page.findByIdAndUpdate(
+ args.id,
+ {
+ archived: false,
+ archivedAt: null,
+ },
+ { new: true }
+ );
+ }
+ } catch (err) {
+ logger.error(err.message, { stack: err.stack });
+ if (err instanceof GraphQLError) {
+ throw new GraphQLError(err.message);
+ }
+ throw new GraphQLError(
+ context.i18next.t('common.errors.internalServerError')
+ );
+ }
+ },
+};

src/schema/types/application.type.ts

@@ -104,6 +104,9 @@ export const ApplicationType = new GraphQLObjectType({
  },
  pages: {
  type: new GraphQLList(PageType),
+ args: {
+ archived: { type: GraphQLBoolean },
+ },
  async resolve(parent: Application, args, context) {
  // Filter the pages based on the access given by app builders.
  const ability = await extendAbilityForPage(context.user, parent);
@@ -113,7 +116,13 @@ export const ApplicationType = new GraphQLObjectType({
  const pages = await Page.aggregate([
  {
  $match: {
- $and: [filter, { _id: { $in: parent.pages } }],
+ $and: [
+ filter,
+ { _id: { $in: parent.pages } },
+ args.archived
+ ? { archived: true }
+ : { archived: { $ne: true } },
+ ],
  },
  },
  {