@knovator/pagecreator-node 0.0.7 → 0.2.0

package/src/types/common.ts

@@ -0,0 +1,130 @@
+import {
+  Document,
+  Model,
+  Types,
+  FilterQuery,
+  QueryOptions,
+  HydratedDocument,
+} from 'mongoose';
+import { ItemsType, WidgetTypes, ItemTypes } from '.';
+
+export type TypesType = { value: string; label: string };
+// export type CollectionItem = {
+//   title: string;
+//   collectionName: string;
+//   filters?: { [key: string]: string };
+//   searchColumns: string[];
+// };
+export interface iConfig {
+  logger: any;
+  catchAsync: (
+    fn: any,
+    modal?: string
+  ) => (req: any, res: any, next: any) => void;
+  collections: CollectionItem[];
+}
+// Collection
+export interface IPageSchema extends Document {
+  name: string;
+  code: string;
+  widgets: string[];
+}
+export interface ISrcSetSchema extends Document {
+  width: number;
+  height: number;
+  screenSize: number;
+  itemId: typeof Types.ObjectId;
+}
+export interface IWidgetSchema extends Document {
+  items: any;
+  name: string;
+  code: string;
+  autoPlay: boolean;
+  isActive: boolean;
+  widgetTitle: string;
+  webPerRow: number;
+  mobilePerRow: number;
+  tabletPerRow: number;
+  itemsType: ItemsType;
+  widgetType: WidgetTypes;
+  collectionName: string;
+  collectionItems: string[];
+}
+export interface IItemSchema extends Document {
+  widgetId: typeof Types.ObjectId;
+  title: string;
+  altText: string;
+  link: string;
+  sequence: number;
+  itemType: ItemTypes;
+  img: any;
+  srcset?: SrcSetItem[];
+}
+export interface SrcSetItem {
+  screenSize: number;
+  width: number;
+  height: number;
+}
+// \ End of Collection
+
+export type CollectionItem = {
+  title: string;
+  collectionName: string;
+  filters?: { [key: string]: string | number | boolean };
+  searchColumns?: string[];
+  match?: ObjectType;
+  project?: ObjectType;
+  lookup?: ObjectType;
+};
+
+export interface IConfig {
+  logger: any;
+  catchAsync: (
+    fn: any,
+    modal?: string
+  ) => (req: any, res: any, next: any) => void;
+  collections: CollectionItem[];
+}
+
+export type EntityType =
+  | IWidgetSchema
+  | IItemSchema
+  | IPageSchema
+  | ISrcSetSchema;
+export type ReturnDocument = EntityType;
+export interface IModel<T> extends Model<T> {
+  paginate: (
+    query: FilterQuery<T>,
+    options?: QueryOptions
+  ) => Promise<HydratedDocument<ReturnDocument>[]>;
+}
+
+export type ObjectType = {
+  [key: string]:
+    | string
+    | number
+    | boolean
+    | null
+    | undefined
+    | string[]
+    | number[]
+    | ObjectType
+    | ObjectType[]
+    | any;
+};
+
+export interface IDefaultValidations {
+  createdBy: string;
+  updatedBy: string;
+  deletedBy: string;
+  deletedAt: string;
+}
+
+// helper.ts
+export interface IWidgetDataSchema {
+  _id: string;
+  code: string;
+  collectionName: string;
+  collectionItems: string[];
+}
+export type IWidgetData = { [key: string]: IWidgetDataSchema };

package/src/types/enums.ts

@@ -0,0 +1,13 @@
+export enum ItemsType {
+  Image = 'Image',
+}
+
+export enum WidgetTypes {
+  FixedCard = 'FixedCard',
+  Carousel = 'Carousel',
+}
+
+export enum ItemTypes {
+  Web = 'Web',
+  Mobile = 'Mobile',
+}

package/src/utils/defaults.ts

@@ -0,0 +1,30 @@
+import { NextFunction } from 'express';
+import { CollectionItem, IConfig, IRequest, IResponse } from '../types';
+import { RESPONSE_CODES, internalServerError, REGEXS } from '../constants';
+
+export const defaults: IConfig = {
+  logger: console as any,
+  catchAsync:
+    (fn: any, modal = '') =>
+    (req: IRequest, res: IResponse, next: NextFunction) => {
+      Promise.resolve(fn(req, res, next)).catch((err) => {
+        let message = (err as Error).message;
+        if (message.match(REGEXS.OBJECTID_CAST_FAILED)) {
+          message = `${modal} not found with given id!`;
+        }
+        // this.logger.error(err.message);
+        res.status(internalServerError).json({
+          code: RESPONSE_CODES.ERROR,
+          message,
+          data: undefined,
+        });
+      });
+    },
+  collections: [] as CollectionItem[],
+};
+
+export const commonExcludedFields = {
+  __v: 0,
+  isDeleted: 0,
+  deletedAt: 0,
+};

package/src/utils/helper.ts

@@ -0,0 +1,133 @@
+import { Widget } from '../models';
+import { commonExcludedFields, defaults } from './defaults';
+import {
+  IWidgetData,
+  IWidgetDataSchema,
+  IWidgetSchema,
+  SrcSetItem,
+} from '../types';
+
+export async function appendCollectionData(widgetData: IWidgetSchema[]) {
+  // reduce widget data to optimize query
+  const newData: IWidgetData = widgetData.reduce(
+    (acc: IWidgetData, widget: IWidgetSchema) => {
+      if (widget.collectionName) {
+        acc[widget.code] = {
+          _id: widget._id,
+          code: widget.code,
+          collectionName: widget.collectionName,
+          collectionItems: widget.collectionItems,
+        };
+      }
+      return acc;
+    },
+    {}
+  );
+  if (Object.keys(newData).length > 0) {
+    const aggregationQuery: any = [
+      {
+        $match: {
+          _id: {
+            $in: Object.values(newData).map(
+              (item: IWidgetDataSchema) => item._id
+            ),
+          },
+        },
+      },
+      {
+        // Get only the fields that are not excluded
+        $project: {
+          _id: 1,
+          code: 1,
+        },
+      },
+    ];
+    let collectionConfig, aggregationQueryPiplelines: any[];
+    Object.keys(newData).forEach((key: string) => {
+      collectionConfig = defaults.collections.find(
+        (c) => c.collectionName === newData[key].collectionName
+      );
+      // Build piplelines with config
+      aggregationQueryPiplelines = [
+        {
+          $match: {
+            _id: {
+              $in: newData[key].collectionItems,
+            },
+            ...(collectionConfig?.match || {}),
+          },
+        },
+        {
+          $project: {
+            ...commonExcludedFields,
+          },
+        },
+      ];
+      // add project config if it exists
+      if (collectionConfig?.project)
+        aggregationQueryPiplelines.push({
+          $project: collectionConfig?.project,
+        });
+      // add lookup config if it exists
+      if (collectionConfig?.lookup)
+        aggregationQueryPiplelines.push({
+          $lookup: collectionConfig?.lookup,
+        });
+      // Build Aggregation Query
+      aggregationQuery.push({
+        $lookup: {
+          from: newData[key].collectionName,
+          pipeline: aggregationQueryPiplelines,
+          as: newData[key].code,
+        },
+      });
+    });
+    // getting collection data by populating widget
+    let aggregationData: any = await Widget.aggregate(aggregationQuery);
+    aggregationData = aggregationData.reduce((acc: any, aggregation: any) => {
+      acc[aggregation.code] = aggregation[aggregation.code];
+      return acc;
+    }, {});
+    // adding collection data to widgets
+    return widgetData.map((widget: IWidgetSchema) => {
+      if (aggregationData[widget.code]) {
+        return {
+          ...widget,
+          collectionItems: aggregationData[widget.code],
+        };
+      }
+      return widget;
+    });
+  }
+  // returning widget data as it is if they do not have dynamic collection
+  return widgetData;
+}
+
+export function buildSrcSetItem(uri: string, setItem: SrcSetItem) {
+  const imageItemArr = uri?.split('/') || [];
+  imageItemArr.splice(
+    imageItemArr.length - 1,
+    0,
+    `${setItem.width}x${setItem.height}`
+  );
+  return imageItemArr.join('/');
+}
+
+export function AddSrcSetsToItems(widgetData: IWidgetSchema) {
+  if (Array.isArray(widgetData.items) && widgetData.items.length > 0) {
+    widgetData.items.forEach((item) => {
+      if (Array.isArray(item.srcset) && item.srcset.length > 0 && item.image) {
+        item.srcSets = item.srcset.reduce(
+          (strArr: string[], setItem: SrcSetItem) => {
+            const imageUri = buildSrcSetItem(item.image.uri, setItem);
+            strArr.push(`${imageUri} ${setItem.screenSize}w`);
+            return strArr;
+          },
+          []
+        );
+
+        item.srcSets = item.srcSets.join(', ');
+      }
+    });
+  }
+}

package/src/utils/responseHandlers.ts

@@ -0,0 +1,54 @@
+import { RESPONSE_CODES, validationError, success, create } from '../constants';
+import { IResponse } from '../types';
+
+export const failureResponse = (data: any, res: IResponse) => {
+	let i = 0;
+	if (data.name === 'ValidationError') {
+		Object.keys(data.errors).forEach((key) => {
+			if (i !== 1) {
+				data.message = data.errors[key].message;
+			}
+			i++;
+		});
+	}
+	res.message = data.message;
+	return res.status(validationError).json({
+		code: RESPONSE_CODES.ERROR,
+		message: data.message ? data.message : data,
+	});
+};
+
+export const successResponse = (data: any, res: IResponse) => {
+	return res.status(success).json({
+		code: RESPONSE_CODES.DEFAULT,
+		message: res.message,
+		data: data,
+	});
+};
+
+export const createdDocumentResponse = (data: any, res: IResponse) => {
+	return res.status(create).json({
+		code: RESPONSE_CODES.DEFAULT,
+		message: res.message,
+		data: data,
+	});
+};
+
+export const recordNotFound = (res: IResponse) => {
+	return res.status(success).json({
+		code: RESPONSE_CODES.DEFAULT,
+		message: res.message,
+		data: {},
+	});
+};
+
+export const inValidParam = (message: any, res: IResponse) => {
+	/* eslint-disable no-useless-escape */
+	message = message.replace(/\"/g, '');
+	res.message = message;
+	return res.status(validationError).json({
+		code: RESPONSE_CODES.ERROR,
+		message: message,
+		data: undefined,
+	});
+};

package/src/utils/validate.ts

@@ -0,0 +1,22 @@
+import { ValidationError } from 'joi';
+import { NextFunction } from 'express';
+import { IRequest, IResponse } from './../types';
+
+import { defaults } from './defaults';
+import { inValidParam, failureResponse } from './responseHandlers';
+
+const validate = (validator: any) => {
+  return async function (req: IRequest, res: IResponse, next: NextFunction) {
+    try {
+      req.body = await validator.validateAsync(req.body);
+      next();
+    } catch (err) {
+      defaults.logger.error('ValidationError', err);
+      if ((err as ValidationError).isJoi)
+        inValidParam((err as Error).message, res);
+      else failureResponse((err as Error).message, res);
+    }
+  };
+};
+
+export default validate;

package/src/utils/validations/item.ts

@@ -0,0 +1,51 @@
+import joi from 'joi';
+import { IItemSchema, IDefaultValidations, ItemTypes } from '../../types';
+
+type ItemValidation = IItemSchema & IDefaultValidations;
+
+const srcset = joi.object().keys({
+  screenSize: joi.number().required(),
+  width: joi.number().required(),
+  height: joi.number().required(),
+});
+
+export const create = joi.object<ItemValidation>({
+  widgetId: joi.string().required(),
+  title: joi.string().required(),
+  altText: joi.string().optional(),
+  link: joi.string().required(),
+  sequence: joi.number().optional(),
+  srcset: joi.array().items(srcset),
+  img: joi.string().allow(null).optional(),
+  itemType: joi
+    .string()
+    .valid(...Object.values(ItemTypes))
+    .optional()
+    .default(ItemTypes.Web),
+  createdBy: joi.any().optional(),
+  updatedBy: joi.any().optional(),
+  deletedBy: joi.any().optional(),
+  deletedAt: joi.any().optional(),
+});
+
+export const update = joi.object<ItemValidation>({
+  widgetId: joi.string().required(),
+  title: joi.string().required(),
+  altText: joi.string().optional(),
+  link: joi.string().required(),
+  sequence: joi.number().optional(),
+  img: joi.string().allow(null).optional(),
+  srcset: joi.array().items(srcset),
+  itemType: joi
+    .string()
+    .valid(...Object.values(ItemTypes))
+    .optional(),
+  createdBy: joi.any().optional(),
+  updatedBy: joi.any().optional(),
+  deletedBy: joi.any().optional(),
+  deletedAt: joi.any().optional(),
+});
+
+export const list = joi.object({
+  search: joi.string().allow('').replace(/\s+/g, '_').default(''),
+});

package/src/utils/validations/page.ts

@@ -0,0 +1,59 @@
+import joi from 'joi';
+import { Page } from '../../models';
+import { getOne } from '../../services/dbService';
+import { VALIDATION } from '../../constants';
+import { IPageSchema, IDefaultValidations } from '../../types';
+
+type PageValidation = IPageSchema & IDefaultValidations;
+
+const checkUnique = async (value: string): Promise<void> => {
+  let result;
+  try {
+    // throws error if document not found
+    result = await getOne(Page, {
+      code: value,
+    });
+    // eslint-disable-next-line no-empty
+  } catch (e) {}
+  if (result) {
+    throw new Error(VALIDATION.WIDGET_EXISTS);
+  }
+};
+
+export const create = joi.object<PageValidation>({
+  name: joi.string().required(),
+  code: joi
+    .string()
+    .uppercase()
+    .replace(/\s+/g, '_')
+    .external(checkUnique)
+    .required(),
+  widgets: joi.array().items(joi.string()).optional(),
+  createdBy: joi.any().optional(),
+  updatedBy: joi.any().optional(),
+  deletedBy: joi.any().optional(),
+  deletedAt: joi.any().optional(),
+});
+
+export const update = joi.object<PageValidation>({
+  name: joi.string().optional(),
+  widgets: joi.array().items(joi.string()).optional(),
+  createdBy: joi.any().optional(),
+  updatedBy: joi.any().optional(),
+  deletedBy: joi.any().optional(),
+  deletedAt: joi.any().optional(),
+});
+
+export const list = joi.object({
+  search: joi.string().allow('').replace(/\s+/g, '_').optional().default(''),
+  options: joi
+    .object({
+      // sort: joi.alternatives().try(joi.object(), joi.string()).optional(),
+      populate: joi.array().items().optional().default([]),
+      offset: joi.number().optional(),
+      page: joi.number().optional(),
+      limit: joi.number().optional(),
+      pagination: joi.boolean().default(false),
+    })
+    .default({}),
+});

package/src/utils/validations/user.ts

@@ -0,0 +1,9 @@
+import joi from 'joi';
+
+export const getWidgetData = joi.object({
+  code: joi.string().required(),
+});
+
+export const getPageData = joi.object({
+  code: joi.string().required(),
+});

package/src/utils/validations/widget.ts

@@ -0,0 +1,118 @@
+import joi from 'joi';
+import { Widget } from '../../models';
+import { defaults } from '../defaults';
+import { VALIDATION } from '../../constants';
+import { getOne } from '../../services/dbService';
+import {
+  ItemsType,
+  WidgetTypes,
+  IWidgetSchema,
+  CollectionItem,
+  IDefaultValidations,
+} from '../../types';
+
+type ItemValidation = IWidgetSchema & IDefaultValidations;
+
+const checkUnique = async (value: string) => {
+  let result;
+  try {
+    // throws error if document found
+    result = await getOne(Widget, {
+      code: value,
+    });
+    // eslint-disable-next-line no-empty
+  } catch (e) {}
+  if (result) {
+    throw new Error(VALIDATION.WIDGET_EXISTS);
+  }
+};
+
+export const create = joi.object<ItemValidation>({
+  name: joi.string().required(),
+  widgetTitle: joi.string().required(),
+  code: joi
+    .string()
+    .uppercase()
+    .replace(/\s+/g, '_')
+    .external(checkUnique)
+    .required(),
+  isActive: joi.boolean().default(true).optional(),
+  autoPlay: joi.boolean().default(false).optional(),
+  webPerRow: joi.number().allow(null).optional(),
+  mobilePerRow: joi.number().allow(null).optional(),
+  tabletPerRow: joi.number().allow(null).optional(),
+  collectionName: joi.string().optional(),
+  collectionItems: joi.array().items(joi.string()).optional(),
+  itemsType: joi
+    .string()
+    .custom((value) => {
+      if (Object.keys(ItemsType).includes(value)) {
+        return value;
+      }
+      const collectionIndex = defaults.collections.findIndex(
+        (collection: CollectionItem) => collection.collectionName === value
+      );
+      if (collectionIndex > -1) {
+        return value;
+      }
+      throw new Error(`${value} is not a valid widget type`);
+    })
+    .optional()
+    .default(ItemsType.Image),
+  widgetType: joi
+    .string()
+    .valid(...Object.values(WidgetTypes))
+    .optional()
+    .default(WidgetTypes.FixedCard),
+  createdBy: joi.any().optional(),
+  updatedBy: joi.any().optional(),
+  deletedBy: joi.any().optional(),
+  deletedAt: joi.any().optional(),
+});
+
+export const update = joi.object<ItemValidation>({
+  name: joi.string().required(),
+  widgetTitle: joi.string().required(),
+  isActive: joi.boolean().optional(),
+  webPerRow: joi.number().allow(null).optional(),
+  mobilePerRow: joi.number().allow(null).optional(),
+  tabletPerRow: joi.number().allow(null).optional(),
+  autoPlay: joi.boolean().default(false).optional(),
+  collectionItems: joi.array().items(joi.string()).optional(),
+  widgetType: joi
+    .string()
+    .valid(...Object.values(WidgetTypes))
+    .optional(),
+  createdBy: joi.any().optional(),
+  updatedBy: joi.any().optional(),
+  deletedBy: joi.any().optional(),
+  deletedAt: joi.any().optional(),
+});
+
+export const list = joi.object({
+  search: joi.string().allow('').optional().default(''),
+  options: joi
+    .object({
+      // sort: joi.alternatives().try(joi.object(), joi.string()).optional(),
+      // populate: joi.array().items().optional(),
+      offset: joi.number().optional(),
+      page: joi.number().optional(),
+      limit: joi.number().optional(),
+    })
+    .default({}),
+  isActive: joi.boolean().optional(),
+  all: joi.boolean().default(false),
+});
+
+export const partialUpdate = joi.object({
+  isActive: joi.boolean().optional(),
+  createdBy: joi.any().optional(),
+  updatedBy: joi.any().optional(),
+  deletedBy: joi.any().optional(),
+  deletedAt: joi.any().optional(),
+});
+
+export const getCollectionData = joi.object({
+  collectionName: joi.string().required(),
+  search: joi.string().allow('').optional().default(''),
+});

package/src/constants/index.d.ts

@@ -1,16 +0,0 @@
-export declare const VALIDATION: {
-    WIDGET_EXISTS: string;
-};
-export declare const RESPONSE_CODES: {
-    DEFAULT: string;
-    ERROR: string;
-};
-export declare const REGEXS: {
-    OBJECTID_CAST_FAILED: RegExp;
-};
-export declare const MONGOOSE_FIND_QUERIES: string[];
-export declare const success = 200;
-export declare const create = 201;
-export declare const internalServerError = 500;
-export declare const validationError = 422;
-export declare const messageRoutePrefix = "msg";

package/src/constants/index.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.messageRoutePrefix = exports.validationError = exports.internalServerError = exports.create = exports.success = exports.MONGOOSE_FIND_QUERIES = exports.REGEXS = exports.RESPONSE_CODES = exports.VALIDATION = void 0;
-exports.VALIDATION = {
-    WIDGET_EXISTS: 'Widget with same code is available',
-};
-exports.RESPONSE_CODES = {
-    DEFAULT: 'SUCCESS',
-    ERROR: 'ERROR',
-};
-exports.REGEXS = {
-    OBJECTID_CAST_FAILED: /Cast to ObjectId failed/gm,
-};
-exports.MONGOOSE_FIND_QUERIES = [
-    'count',
-    'find',
-    'findOne',
-    'findOneAndDelete',
-    'findOneAndRemove',
-    'findOneAndUpdate',
-    'update',
-    'updateOne',
-    'updateMany',
-];
-exports.success = 200;
-exports.create = 201;
-exports.internalServerError = 500;
-exports.validationError = 422;
-exports.messageRoutePrefix = 'msg';
-//# sourceMappingURL=index.js.map

package/src/constants/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/node/src/constants/index.ts"],"names":[],"mappings":";;;AAAa,QAAA,UAAU,GAAG;IACzB,aAAa,EAAE,oCAAoC;CACnD,CAAC;AACW,QAAA,cAAc,GAAG;IAC7B,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;CACd,CAAC;AACW,QAAA,MAAM,GAAG;IACrB,oBAAoB,EAAE,2BAA2B;CACjD,CAAC;AACW,QAAA,qBAAqB,GAAG;IACpC,OAAO;IACP,MAAM;IACN,SAAS;IACT,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;IAClB,QAAQ;IACR,WAAW;IACX,YAAY;CACZ,CAAC;AACW,QAAA,OAAO,GAAG,GAAG,CAAC;AACd,QAAA,MAAM,GAAG,GAAG,CAAC;AACb,QAAA,mBAAmB,GAAG,GAAG,CAAC;AAC1B,QAAA,eAAe,GAAG,GAAG,CAAC;AACtB,QAAA,kBAAkB,GAAG,KAAK,CAAC"}

package/src/controllers/PageController.d.ts

@@ -1,4 +0,0 @@
-export declare const createPage: (req: any, res: any, next: any) => void;
-export declare const updatePage: (req: any, res: any, next: any) => void;
-export declare const deletePage: (req: any, res: any, next: any) => void;
-export declare const getPages: (req: any, res: any, next: any) => void;