@knovator/pagecreator-node 0.0.7 → 0.2.0

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;

package/src/models/SrcSet.ts

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

@@ -0,0 +1,44 @@
+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/models/index.ts

@@ -0,0 +1,6 @@
+import Widget from './Widget';
+import Item from './Item';
+import Page from './Page';
+import SrcSet from './SrcSet';
+
+export { Widget, Item, Page, SrcSet };

package/src/plugins/softDelete.ts

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

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

package/src/routes/PageRoute.ts

@@ -0,0 +1,31 @@
+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 pageValidation from '../utils/validations/page';
+import * as pageController from '../controllers/PageController';
+
+const descriptorPrefix = process.env['PAGECREATOR_DESCRIPTOR_PREFIX'] || '';
+const routes = express.Router() as IRouter;
+routes.use(express.json());
+
+// Get all pages
+routes
+  .post(`/list`, validate(pageValidation.list), pageController.getPages)
+  .descriptor(`${descriptorPrefix}page.getAll`);
+// Create a page
+routes
+  .post(`/`, validate(pageValidation.create), pageController.createPage)
+  .descriptor(`${descriptorPrefix}page.create`);
+// Update a page
+routes
+  .put(`/:id`, validate(pageValidation.update), pageController.updatePage)
+  .descriptor(`${descriptorPrefix}page.update`);
+// Delete a page
+routes
+  .delete(`/:id`, pageController.deletePage)
+  .descriptor(`${descriptorPrefix}page.delete`);
+
+export default routes;

package/src/routes/UserRoute.ts

@@ -0,0 +1,32 @@
+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 userValidation from '../utils/validations/user';
+import * as userController from '../controllers/UserController';
+
+const descriptorPrefix = process.env['PAGECREATOR_DESCRIPTOR_PREFIX'] || '';
+const routes = express.Router() as IRouter;
+routes.use(express.json());
+
+// Item Routes
+// Get Widget Data
+routes
+  .post(
+    `/widget-data`,
+    validate(userValidation.getWidgetData),
+    userController.getWidgetData
+  )
+  .descriptor(`${descriptorPrefix}user.getWidgetData`);
+// Get Page Data
+routes
+  .post(
+    '/page-data',
+    validate(userValidation.getPageData),
+    userController.getPageData
+  )
+  .descriptor(`${descriptorPrefix}user.getPageData`);
+
+export default routes;

package/src/routes/WidgetRoute.ts

@@ -0,0 +1,56 @@
+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 widgetValidation from '../utils/validations/widget';
+import * as widgetController from '../controllers/WidgetController';
+
+const descriptorPrefix = process.env['PAGECREATOR_DESCRIPTOR_PREFIX'] || '';
+const routes = express.Router() as IRouter;
+routes.use(express.json());
+
+// Widget Routes
+// Get widget types
+routes
+  .get('/widget-types', widgetController.getItemsTypes)
+  .descriptor(`${descriptorPrefix}widget.getItemsTypes`);
+// Get widget selection types
+routes
+  .get('/selection-types', widgetController.getWidgetTypes)
+  .descriptor(`${descriptorPrefix}widget.getWidgetTypes`);
+// Get all widgets
+routes
+  .post(`/list`, validate(widgetValidation.list), widgetController.getWidgets)
+  .descriptor(`${descriptorPrefix}widget.getAll`);
+// Create a widget
+routes
+  .post(`/`, validate(widgetValidation.create), widgetController.createWidget)
+  .descriptor(`${descriptorPrefix}widget.create`);
+// Update a widget
+routes
+  .put(`/:id`, validate(widgetValidation.update), widgetController.updateWidget)
+  .descriptor(`${descriptorPrefix}widget.update`);
+// Partial Update a widget
+routes
+  .patch(
+    `/:id`,
+    validate(widgetValidation.partialUpdate),
+    widgetController.partialUpdateWidget
+  )
+  .descriptor(`${descriptorPrefix}widget.partialUpdate`);
+// Delete a widget
+routes
+  .delete(`/:id`, widgetController.deleteWidget)
+  .descriptor(`${descriptorPrefix}widget.delete`);
+// Get dynamic collection data
+routes
+  .post(
+    '/collection-data',
+    validate(widgetValidation.getCollectionData),
+    widgetController.getCollectionData
+  )
+  .descriptor(`${descriptorPrefix}widget.getCollectionData`);
+
+export default routes;

package/src/services/dbService.ts

@@ -0,0 +1,82 @@
+import {
+  Model,
+  FilterQuery,
+  QueryOptions,
+  ProjectionType,
+  HydratedDocument,
+  QueryWithHelpers,
+} from 'mongoose';
+import { EntityType, IModel, ReturnDocument } from '../types';
+
+// create
+export async function create<T extends EntityType>(
+  Modal: Model<T>,
+  data: Partial<T>
+): Promise<ReturnDocument> {
+  const modalInstance = new Modal(data);
+  return await modalInstance.save();
+}
+// update
+export async function update<T extends EntityType>(
+  Modal: Model<T>,
+  query: FilterQuery<EntityType>,
+  data: Partial<T>
+): Promise<ReturnDocument | undefined> {
+  await getOne(Modal, query);
+  const result = await Modal.findOneAndUpdate(query, data, { new: true });
+  return result || undefined;
+}
+// soft-delete
+export async function remove<T extends EntityType>(
+  Modal: Model<T>,
+  query: FilterQuery<EntityType>
+): Promise<ReturnDocument> {
+  const modalInstance = await getOne(Modal, query);
+  return await modalInstance.remove();
+}
+// delete-all
+export async function deleteAll<T extends EntityType>(Modal: Model<T>, query: FilterQuery<T>) {
+  return Modal.deleteMany(query);
+}
+// get-all
+export function getAll<T extends EntityType>(
+  Modal: Model<T>,
+  query: FilterQuery<EntityType> = {},
+  options?: QueryOptions<EntityType>,
+  projection?: ProjectionType<EntityType>
+  // eslint-disable-next-line @typescript-eslint/ban-types
+): QueryWithHelpers<Array<T>, T, {}, T> {
+  return Modal.find(query, projection, options);
+}
+// list
+export async function list<T extends EntityType>(
+  Modal: IModel<T>,
+  where: FilterQuery<T>,
+  options: QueryOptions<T>
+): Promise<ReturnDocument[]> {
+  try {
+    const documents = Modal.paginate(where, options);
+    return documents;
+  } catch (error) {
+    throw new Error((error as Error).message);
+  }
+}
+// get-one
+export async function getOne<T extends EntityType>(
+  Modal: Model<T>,
+  query: FilterQuery<EntityType>,
+  projection?: ProjectionType<EntityType>
+): Promise<HydratedDocument<T>> {
+  const modalInstance: HydratedDocument<T> | null = await Modal.findOne(
+    query,
+    projection
+  );
+  if (!modalInstance)
+    throw new Error(`Record not found ${Modal.name ? `in ${Modal.name}` : ''}`);
+
+  return modalInstance;
+}
+// bulk-insert
+export async function bulkInsert<T extends EntityType>(Modal: Model<T>, docs: T[]): Promise<ReturnDocument[]> {
+  return await Modal.insertMany(docs);
+}

package/src/types/{IRequest.d.ts → IRequest.ts}

@@ -1,6 +1,7 @@
 import { Request } from 'express';
+
 export interface IRequest extends Request {
-    i18n?: {
-        t: (key: string) => string;
-    };
+  i18n?: {
+    t: (key: string) => string;
+  };
 }

package/src/types/{IResponse.d.ts → IResponse.ts}

@@ -1,6 +1,7 @@
 import { Response } from 'express';
+
 export interface IResponse extends Response {
-    message?: string;
-    data?: unknown;
-    code?: number;
+  message?: string;
+  data?: unknown;
+  code?: number;
 }

package/src/types/{Router.d.ts → Router.ts}

@@ -1,4 +1,5 @@
 import { Router } from 'express';
+
 export interface IRouter extends Router {
-    descriptor: (text: string) => void;
+  descriptor: (text: string) => void;
 }