@knovator/pagecreator-node 0.2.0 → 0.3.0

package/src/controllers/UserController.ts

@@ -1,265 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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;

package/src/models/SrcSet.ts

@@ -1,16 +0,0 @@
-import { Schema, model, Types, Model } from 'mongoose';
-import { ISrcSetSchema } from '../types';
-
-const SrcSetSchema = new Schema<ISrcSetSchema>({
-  width: Number,
-  height: Number,
-  screenSize: Number,
-  itemId: {
-    type: Types.ObjectId,
-    ref: 'Item',
-  },
-});
-
-const SrcSet: Model<ISrcSetSchema> = model('SrcSet', SrcSetSchema);
-
-export default SrcSet;

package/src/models/Widget.ts

@@ -1,44 +0,0 @@
-import { Schema, model, Types } from 'mongoose';
-import mongoosePaginate from 'mongoose-paginate-v2';
-import { softDeletePlugin } from '../plugins/softDelete';
-import { IModel, IWidgetSchema, WidgetTypes, ItemsType } from '../types';
-
-const WidgetSchema = new Schema<IWidgetSchema>({
-  name: String,
-  code: String,
-  autoPlay: {
-    type: Boolean,
-    default: false,
-  },
-  isActive: {
-    type: Boolean,
-    default: true,
-  },
-  widgetTitle: String,
-  webPerRow: Number,
-  mobilePerRow: Number,
-  tabletPerRow: Number,
-  collectionName: String,
-  collectionItems: [{ type: Types.ObjectId, refPath: 'collectionName' }],
-  itemsType: {
-    type: String,
-    default: ItemsType.Image,
-    required: true,
-  },
-  widgetType: {
-    type: String,
-    enum: Object.values(WidgetTypes),
-    default: WidgetTypes.FixedCard,
-    required: true,
-  },
-});
-
-WidgetSchema.plugin(softDeletePlugin);
-WidgetSchema.plugin(mongoosePaginate);
-
-const Widget = model(
-  'Widget',
-  WidgetSchema
-) as unknown as IModel<IWidgetSchema>;
-
-export default Widget;

package/src/plugins/softDelete.ts

@@ -1,84 +0,0 @@
-import mongoose from 'mongoose';
-
-export type TWithSoftDeleted = {
-  isDeleted?: boolean;
-  deletedAt?: Date | null;
-};
-
-type TDocument = TWithSoftDeleted & mongoose.Document;
-
-const softDeletePlugin = (schema: mongoose.Schema) => {
-  schema.add({
-    isDeleted: {
-      type: Boolean,
-      required: true,
-      default: false,
-    },
-    deletedAt: {
-      type: Date,
-      default: null,
-    },
-  });
-
-  const typesFindQueryMiddleware = [
-    'count',
-    'find',
-    'findOne',
-    'findOneAndDelete',
-    'findOneAndRemove',
-    'findOneAndUpdate',
-    'update',
-    'updateOne',
-    'updateMany',
-  ];
-
-  const setDocumentIsDeleted = async (doc: TDocument) => {
-    doc.isDeleted = true;
-    doc.deletedAt = new Date();
-    doc.$isDeleted(true);
-    await doc.save();
-  };
-
-  const excludeInFindQueriesIsDeleted = async function (
-    this: mongoose.FilterQuery<TDocument>,
-    next: mongoose.CallbackWithoutResultAndOptionalError
-  ) {
-    this['where']({ isDeleted: false });
-    next();
-  };
-
-  const excludeInDeletedInAggregateMiddleware = async function (
-    this: mongoose.Aggregate<any>,
-    next: mongoose.CallbackWithoutResultAndOptionalError
-  ) {
-    this.pipeline().unshift({ $match: { isDeleted: false } });
-    next();
-  };
-
-  schema.pre(
-    'remove',
-    async function (
-      this: TDocument,
-      next: mongoose.CallbackWithoutResultAndOptionalError
-    ) {
-      await setDocumentIsDeleted(this);
-      next();
-    }
-  );
-
-  typesFindQueryMiddleware.forEach((type: any) => {
-    schema.pre(type, excludeInFindQueriesIsDeleted);
-  });
-
-  schema.pre('aggregate', excludeInDeletedInAggregateMiddleware);
-
-  schema.method('toJSON', function () {
-    const obj: TDocument = this.toObject();
-    delete obj.isDeleted;
-    delete obj.deletedAt;
-
-    return obj;
-  });
-};
-
-export { softDeletePlugin };

package/src/routes/ItemRoute.ts

@@ -1,32 +0,0 @@
-import express from 'express';
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-require('express-list-endpoints-descriptor')(express);
-import { IRouter } from '../types';
-
-import validate from '../utils/validate';
-import * as itemValidation from '../utils/validations/item';
-import * as itemController from '../controllers/ItemController';
-
-const descriptorPrefix = process.env['PAGECREATOR_DESCRIPTOR_PREFIX'] || '';
-const routes = express.Router() as IRouter;
-routes.use(express.json());
-
-// Item Routes
-// Get all items
-routes
-  .get(`/:widgetId`, validate(itemValidation.list), itemController.getItems)
-  .descriptor(`${descriptorPrefix}item.getAll`);
-// Create a item
-routes
-  .post(`/`, validate(itemValidation.create), itemController.createItem)
-  .descriptor(`${descriptorPrefix}item.create`);
-// Update a item
-routes
-  .put(`/:id`, validate(itemValidation.update), itemController.updateItem)
-  .descriptor(`${descriptorPrefix}item.update`);
-// Delete a item
-routes
-  .delete(`/:id`, itemController.deleteItem)
-  .descriptor(`${descriptorPrefix}item.delete`);
-
-export default routes;