@knovator/pagecreator-node 0.0.6 → 0.2.0

package/src/controllers/ItemController.ts

@@ -0,0 +1,139 @@
+import { Types } from 'mongoose';
+import { SrcSet, Item } from '../models';
+import {
+  create,
+  remove,
+  update,
+  deleteAll,
+  bulkInsert,
+} from '../services/dbService';
+import {
+  successResponse,
+  createdDocumentResponse,
+} from '../utils/responseHandlers';
+
+import { commonExcludedFields, defaults } from '../utils/defaults';
+import { IRequest, IResponse, IItemSchema, SrcSetItem } from '../types';
+
+const catchAsync = (fn: any) => {
+  return defaults.catchAsync(fn, 'Notification');
+};
+
+export const createItem = catchAsync(async (req: IRequest, res: IResponse) => {
+  const data = req.body;
+  const createdItem = (await create(Item, data)) as IItemSchema;
+  let response = createdItem.toJSON();
+  if (data.srcset) {
+    response = {
+      ...response,
+      srcset: (await updateItemSrcSet(
+        createdItem._id,
+        data.srcset
+      )) as SrcSetItem[],
+    };
+  }
+  res.message = req?.i18n?.t('item.create');
+  return createdDocumentResponse(response, res);
+});
+
+export const updateItem = catchAsync(async (req: IRequest, res: IResponse) => {
+  const data = req.body;
+  const _id = req.params['id'];
+  const updatedItem = (await update(Item, { _id }, data)) as IItemSchema;
+  let response = updatedItem.toJSON();
+  if (data.srcset) {
+    response = {
+      ...response,
+      srcset: (await updateItemSrcSet(_id, data.srcset)) as SrcSetItem[],
+    };
+  }
+  res.message = req?.i18n?.t('item.update');
+  return successResponse(response, res);
+});
+
+export const deleteItem = catchAsync(async (req: IRequest, res: IResponse) => {
+  const _id = new Types.ObjectId(req.params['id']);
+  const deletedItem = await remove(Item, { _id });
+  res.message = req?.i18n?.t('item.delete');
+  return successResponse(deletedItem, res);
+});
+
+export const getItems = catchAsync(async (req: IRequest, res: IResponse) => {
+  const widgetId = req.params['widgetId'];
+  const items = await Item.aggregate([
+    {
+      $match: {
+        widgetId: new Types.ObjectId(widgetId),
+        isDeleted: false,
+      },
+    },
+    {
+      $project: {
+        ...commonExcludedFields,
+      },
+    },
+    {
+      $lookup: {
+        from: 'file',
+        let: { imgId: '$img' },
+        as: 'img',
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: ['$_id', '$$imgId'],
+              },
+            },
+          },
+          {
+            $project: {
+              ...commonExcludedFields,
+              width: 0,
+              module: 0,
+              height: 0,
+            },
+          },
+        ],
+      },
+    },
+    {
+      $lookup: {
+        from: 'srcsets',
+        let: { item: '$_id' },
+        as: 'srcset',
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $eq: ['$itemId', '$$item'],
+              },
+            },
+          },
+          {
+            $project: {
+              ...commonExcludedFields,
+              _id: 0,
+              itemId: 0,
+            },
+          },
+        ],
+      },
+    },
+    {
+      $unwind: '$img',
+    },
+  ]);
+  res.message = req?.i18n?.t('item.getAll');
+  return successResponse(items, res);
+});
+
+const updateItemSrcSet = async (itemId: string, srcSets: SrcSetItem[]) => {
+  await deleteAll(SrcSet, { itemId });
+  const modifiedSrcSets = srcSets.map((set) => ({
+    ...set,
+    itemId,
+  }));
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return await bulkInsert(SrcSet, modifiedSrcSets);
+};

package/src/controllers/PageController.ts

@@ -0,0 +1,65 @@
+import { Types } from 'mongoose';
+import { Page } from './../models';
+import { create, remove, update, list } from '../services/dbService';
+import {
+  successResponse,
+  createdDocumentResponse,
+} from './../utils/responseHandlers';
+import { IRequest, IResponse } from '../types';
+
+import { defaults } from '../utils/defaults';
+
+const catchAsync = (fn: any) => {
+  return defaults.catchAsync(fn, 'Page');
+};
+
+export const createPage = catchAsync(async (req: IRequest, res: IResponse) => {
+  const data = req.body;
+  const page = await create(Page, data);
+  res.message = req?.i18n?.t('page.create');
+  return createdDocumentResponse(page, res);
+});
+
+export const updatePage = catchAsync(async (req: IRequest, res: IResponse) => {
+  const data = req.body;
+  const _id = req.params['id'];
+  const updatedPage = await update(Page, { _id }, data);
+  res.message = req?.i18n?.t('page.update');
+  return successResponse(updatedPage, res);
+});
+
+export const deletePage = catchAsync(async (req: IRequest, res: IResponse) => {
+  const _id = new Types.ObjectId(req.params['id']);
+  const createdPage = await remove(Page, { _id });
+  res.message = req?.i18n?.t('page.delete');
+  return successResponse(createdPage, res);
+});
+
+export const getPages = catchAsync(async (req: IRequest, res: IResponse) => {
+  const search = req.body.search || '';
+  const { page, limit, populate } = req.body.options;
+  const customOptions = {
+    populate,
+    ...(page && limit ? { page, limit } : {}),
+  };
+  const query = {
+    isDeleted: false,
+    $or: [
+      {
+        name: {
+          $regex: search,
+          $options: 'i',
+        },
+      },
+      {
+        code: {
+          $regex: search,
+          $options: 'i',
+        },
+      },
+    ],
+  };
+  const pages = await list(Page, query, customOptions);
+  res.message = req?.i18n?.t('page.getAll');
+  return successResponse(pages, res);
+});

package/src/controllers/UserController.ts

@@ -0,0 +1,265 @@
+import { AggregateOptions, models } from 'mongoose';
+import { Widget, Page } from './../models';
+import { AddSrcSetsToItems, appendCollectionData } from '../utils/helper';
+import { successResponse } from './../utils/responseHandlers';
+import { defaults, commonExcludedFields } from '../utils/defaults';
+import { IPageSchema, IRequest, IResponse, IWidgetSchema } from '../types';
+
+const catchAsync = (fn: any) => {
+  return defaults.catchAsync(fn, 'User');
+};
+
+// TO Do: Optimize the following
+export const getWidgetData = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const { code } = req.body;
+    const widgetDataArr = (await Widget.aggregate([
+      {
+        $match: {
+          isDeleted: false,
+          isActive: true,
+          code,
+        },
+      },
+      {
+        // Get only the fields that are not excluded
+        $project: {
+          ...commonExcludedFields,
+        },
+      },
+      {
+        // Get Items data
+        $lookup: {
+          from: 'items',
+          let: { widget: '$_id' },
+          pipeline: [
+            {
+              $match: {
+                $expr: {
+                  $eq: ['$widgetId', '$$widget'],
+                },
+                isDeleted: false,
+              },
+            },
+            {
+              $project: {
+                ...commonExcludedFields,
+              },
+            },
+            {
+              $lookup: {
+                from: 'file',
+                let: { img: '$img' },
+                as: 'image',
+                pipeline: [
+                  {
+                    $match: {
+                      $expr: {
+                        $eq: ['$_id', '$$img'],
+                      },
+                    },
+                  },
+                  {
+                    $project: {
+                      _id: 1,
+                      uri: 1,
+                    },
+                  },
+                ],
+              },
+            },
+            {
+              $lookup: {
+                from: 'srcsets',
+                let: { item: '$_id' },
+                as: 'srcset',
+                pipeline: [
+                  {
+                    $match: {
+                      $expr: {
+                        $eq: ['$itemId', '$$item'],
+                      },
+                    },
+                  },
+                  {
+                    $project: {
+                      ...commonExcludedFields,
+                      _id: 0,
+                      itemId: 0,
+                    },
+                  },
+                ],
+              },
+            },
+            {
+              $unwind: '$image',
+            },
+          ],
+          as: 'items',
+        },
+      },
+    ])) as Array<IWidgetSchema>;
+
+    if (!widgetDataArr.length) throw new Error(`Widget not found`);
+    const widgetData = widgetDataArr[0];
+
+    if (widgetData.collectionName && widgetData.collectionItems.length > 0) {
+      const collectionConfig = defaults.collections.find(
+        (c) => c.collectionName === widgetData.collectionName
+      );
+      const aggregateQuery: AggregateOptions = {
+        $match: {
+          _id: {
+            $in: widgetData.collectionItems,
+          },
+          ...(collectionConfig?.match || {}),
+        },
+      };
+      if (collectionConfig?.project)
+        aggregateQuery['$project'] = collectionConfig?.project;
+      if (collectionConfig?.lookup)
+        aggregateQuery['$lookup'] = collectionConfig?.lookup;
+
+      const aggregateQueryItem: AggregateOptions[] = [];
+      if (aggregateQuery['$match'])
+        aggregateQueryItem.push({ $match: aggregateQuery['$match'] });
+      if (aggregateQuery['$lookup'])
+        aggregateQueryItem.push({ $lookup: aggregateQuery['$lookup'] });
+      if (aggregateQuery['$project'])
+        aggregateQueryItem.push({ $project: aggregateQuery['$project'] });
+
+      const collectionItems = await models[widgetData.collectionName].aggregate(
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        aggregateQueryItem
+      );
+      widgetData.collectionItems = collectionItems;
+    }
+    AddSrcSetsToItems(widgetData);
+    return successResponse(widgetData, res);
+  }
+);
+
+// TO Do: Optimize the following
+export const getPageData = catchAsync(async (req: IRequest, res: IResponse) => {
+  const { code } = req.body;
+  const pageData: any = (await Page.aggregate([
+    {
+      $match: {
+        isDeleted: false,
+        code: code,
+      },
+    },
+    {
+      $project: {
+        isDeleted: 0,
+        deletedAt: 0,
+        __v: 0,
+      },
+    },
+    {
+      $lookup: {
+        from: 'widgets',
+        let: { widgets: '$widgets' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $in: ['$_id', '$$widgets'],
+              },
+              isDeleted: false,
+            },
+          },
+          {
+            $project: {
+              widgetId: 0,
+              sequence: 0,
+              ...commonExcludedFields,
+            },
+          },
+          {
+            $lookup: {
+              from: 'items',
+              let: { widget: '$_id' },
+              pipeline: [
+                {
+                  $match: {
+                    $expr: {
+                      $eq: ['$widgetId', '$$widget'],
+                    },
+                    isDeleted: false,
+                  },
+                },
+                {
+                  $project: {
+                    ...commonExcludedFields,
+                  },
+                },
+                {
+                  $lookup: {
+                    from: 'file',
+                    let: { img: '$img' },
+                    as: 'image',
+                    pipeline: [
+                      {
+                        $match: {
+                          $expr: {
+                            $eq: ['$_id', '$$img'],
+                          },
+                        },
+                      },
+                      {
+                        $project: {
+                          _id: 1,
+                          uri: 1,
+                        },
+                      },
+                    ],
+                  },
+                },
+                {
+                  $lookup: {
+                    from: 'srcsets',
+                    let: { item: '$_id' },
+                    as: 'srcset',
+                    pipeline: [
+                      {
+                        $match: {
+                          $expr: {
+                            $eq: ['$itemId', '$$item'],
+                          },
+                        },
+                      },
+                      {
+                        $project: {
+                          ...commonExcludedFields,
+                          _id: 0,
+                          itemId: 0,
+                        },
+                      },
+                    ],
+                  },
+                },
+                {
+                  $unwind: '$image',
+                },
+              ],
+              as: 'items',
+            },
+          },
+        ],
+        as: 'widgets',
+      },
+    },
+  ])) as Array<IPageSchema>;
+
+  if (!pageData.length) throw new Error('Page not found');
+  pageData[0].widgets = await appendCollectionData(pageData[0].widgets);
+  if (Array.isArray(pageData[0].widgets) && pageData[0].widgets.length > 0) {
+    pageData[0].widgets.forEach((widget: IWidgetSchema) => {
+      AddSrcSetsToItems(widget);
+    });
+  }
+  res.message = req?.i18n?.t('user.pageData');
+  return successResponse(pageData[0], res);
+});

package/src/controllers/WidgetController.ts

@@ -0,0 +1,165 @@
+import { Types, model, Schema, models } from 'mongoose';
+import mongoosePaginate from 'mongoose-paginate-v2';
+import { Widget } from './../models';
+import { create, remove, update, list, getAll } from '../services/dbService';
+import {
+  successResponse,
+  createdDocumentResponse,
+} from './../utils/responseHandlers';
+
+import { defaults } from '../utils/defaults';
+import {
+  CollectionItem,
+  IModel,
+  IRequest,
+  IResponse,
+  WidgetTypes,
+  TypesType,
+  ItemsType,
+} from '../types';
+
+const catchAsync = (fn: any) => {
+  return defaults.catchAsync(fn, 'Notification');
+};
+
+export const createWidget = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const data = req.body;
+    const notification = await create(Widget, data);
+    res.message = req?.i18n?.t('widget.create');
+    return createdDocumentResponse(notification, res);
+  }
+);
+
+export const updateWidget = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const data = req.body;
+    const _id = req.params['id'];
+    const updatedNotification = await update(Widget, { _id }, data);
+    res.message = req?.i18n?.t('widget.update');
+    return successResponse(updatedNotification, res);
+  }
+);
+
+export const deleteWidget = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const _id = new Types.ObjectId(req.params['id']);
+    const deletedNotification = await remove(Widget, { _id });
+    res.message = req?.i18n?.t('widget.delete');
+    return successResponse(deletedNotification, res);
+  }
+);
+
+export const getWidgets = catchAsync(async (req: IRequest, res: IResponse) => {
+  const search = req.body.search || '';
+  const { page, limit } = req.body.options;
+  const all =
+    (typeof req.body.all !== 'undefined' && req.body.all === true) || false;
+  const isActive =
+    typeof req.body.isActive !== 'undefined'
+      ? req.body.isActive || false
+      : null;
+  const customOptions = {
+    pagination: !all,
+    ...(page && limit ? { page, limit } : {}),
+  };
+  const query = {
+    isDeleted: false,
+    isActive: { $in: isActive === null ? [true, false] : [isActive] },
+    $or: [
+      {
+        name: {
+          $regex: search,
+          $options: 'i',
+        },
+      },
+      {
+        code: {
+          $regex: search,
+          $options: 'i',
+        },
+      },
+    ],
+  };
+  const notifications = await list(Widget, query, customOptions);
+  res.message = req?.i18n?.t('widget.getAll');
+  return successResponse(notifications, res);
+});
+
+export const partialUpdateWidget = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const data = req.body;
+    const _id = req.params['id'];
+    const updatedNotification = await update(Widget, { _id }, data);
+    res.message = req?.i18n?.t('widget.partialUpdate');
+    return successResponse(updatedNotification, res);
+  }
+);
+
+export const getItemsTypes = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const itemsTypes: TypesType[] = [
+      {
+        value: Object.keys(ItemsType)[0],
+        label: Object.values(ItemsType)[0],
+      },
+    ];
+    defaults.collections.forEach((item: CollectionItem) => {
+      itemsTypes.push({
+        value: item.collectionName,
+        label: item.title,
+      });
+    });
+    res.message = req?.i18n?.t('widget.getItemsTypes');
+    return successResponse(itemsTypes, res);
+  }
+);
+
+export const getWidgetTypes = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const widgetTypes = Object.entries(WidgetTypes).map((e) => ({
+      label: e[1],
+      value: e[0],
+    }));
+    res.message = req?.i18n?.t('widget.getWidgetTypes');
+    return successResponse(widgetTypes, res);
+  }
+);
+
+export const getCollectionData = catchAsync(
+  async (req: IRequest, res: IResponse) => {
+    const limit = 10;
+    const { search, collectionName } = req.body;
+    const collectionItem: CollectionItem | undefined =
+      defaults.collections.find(
+        (collection) => collection.collectionName === collectionName
+      );
+    if (!collectionItem) {
+      throw new Error(`No collection is specified with ${collectionName}`);
+    }
+    // setting up mongoose model
+    let TempModel = models[collectionName] as unknown as IModel<any>;
+    if (!TempModel) {
+      const tempSchema = new Schema({}, { strict: false });
+      TempModel = model(collectionName, tempSchema) as unknown as IModel<any>;
+    }
+    // fetching data
+    let query: any = collectionItem.filters || {};
+    if (search) {
+      query = {
+        ...query,
+        $or: collectionItem.searchColumns
+          ? collectionItem.searchColumns.map((column) => ({
+              [column]: {
+                $regex: search,
+                $options: 'i',
+              },
+            }))
+          : [],
+      };
+    }
+    const collectionData = await getAll(TempModel, query, { limit });
+    res.message = req?.i18n?.t('widget.getCollectionData');
+    return successResponse({ docs: collectionData }, res);
+  }
+);

package/src/index.ts

@@ -0,0 +1,29 @@
+import { defaults } from './utils/defaults';
+import WidgetRoutes from './routes/WidgetRoute';
+import ItemRoutes from './routes/ItemRoute';
+import PageRoutes from './routes/PageRoute';
+import UserRoutes from './routes/UserRoute';
+import { Widget, Item, Page } from './models';
+import { IConfig } from './types';
+
+function setConfig(config: Partial<IConfig>) {
+  if (config.logger) {
+    defaults.logger = config.logger;
+  }
+  if (typeof config.catchAsync === 'function')
+    defaults.catchAsync = config.catchAsync;
+  if (Array.isArray(config.collections)) {
+    defaults.collections = config.collections;
+  }
+}
+
+export {
+  WidgetRoutes,
+  ItemRoutes,
+  PageRoutes,
+  UserRoutes,
+  Widget,
+  Item,
+  Page,
+  setConfig,
+};

package/src/models/Item.ts

@@ -0,0 +1,29 @@
+import { Schema, Types, model } from 'mongoose';
+import mongoosePaginate from 'mongoose-paginate-v2';
+import { softDeletePlugin } from '../plugins/softDelete';
+import { IModel, IItemSchema, ItemTypes } from '../types';
+
+const ItemSchema = new Schema<IItemSchema>({
+  widgetId: {
+    type: Types.ObjectId,
+    ref: 'Widget',
+  },
+  title: String,
+  altText: String,
+  link: String,
+  sequence: Number,
+  img: { type: Schema.Types.ObjectId, ref: 'file' },
+  itemType: {
+    type: String,
+    enum: Object.values(ItemTypes),
+    default: ItemTypes.Web,
+    required: true,
+  },
+});
+
+ItemSchema.plugin(softDeletePlugin);
+ItemSchema.plugin(mongoosePaginate);
+
+const Item = model('Item', ItemSchema) as unknown as IModel<IItemSchema>;
+
+export default Item;

package/src/models/Page.ts

@@ -0,0 +1,17 @@
+import { Schema, model, Types } from 'mongoose';
+import mongoosePaginate from 'mongoose-paginate-v2';
+import { softDeletePlugin } from '../plugins/softDelete';
+import { IModel, IPageSchema } from '../types';
+
+const PageSchema = new Schema<IPageSchema>({
+  name: String,
+  code: String,
+  widgets: [{ type: Types.ObjectId, ref: 'Widget' }],
+});
+
+PageSchema.plugin(softDeletePlugin);
+PageSchema.plugin(mongoosePaginate);
+
+const Page = model('Page', PageSchema) as unknown as IModel<IPageSchema>;
+
+export default Page;