@knovator/pagecreator-node 1.2.0 → 1.2.2

package/src/services/dbService.ts

@@ -1,102 +0,0 @@
-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<T | 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<T | undefined> {
-  const modalInstance = await getOne(Modal, query);
-  await modalInstance.remove();
-  return modalInstance;
-}
-// 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);
-}
-
-export async function checkUnique<T extends EntityType>({
-Modal,
-uniqueField,
-errorMessage,
-value
-}: {
-  Modal: Model<T>,
-  uniqueField: keyof T,
-  value: any,
-  errorMessage: string
-}): Promise<void> {
-  const query: FilterQuery<T> = { [uniqueField]: value } as FilterQuery<T>;
-  let result;
-  try {
-    result = await getOne(Modal, query);
-  } catch (error) {}
-  if(result) throw new Error(errorMessage)
-}

package/src/types/common.ts

@@ -1,172 +0,0 @@
-import {
-  Document,
-  Model,
-  Models,
-  Types,
-  FilterQuery,
-  QueryOptions,
-  HydratedDocument,
-} from 'mongoose';
-import { ItemsType, WidgetTypes, ItemTypes } from '.';
-
-export type TypesType = { value: string; label: string };
-
-export type LanguageSchemaFieldType = { [key: string]: 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;
-  slug: string;
-  canDel: boolean;
-  widgets: string[];
-}
-export interface ITabSchema extends Document {
-  name: string;
-  names: LanguageSchemaFieldType;
-  widgetId: typeof Types.ObjectId;
-  collectionItems: 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;
-  widgetTitles: LanguageSchemaFieldType;
-  webPerRow: number;
-  mobilePerRow: number;
-  tabletPerRow: number;
-  itemsType: ItemsType;
-  widgetType: WidgetTypes;
-  collectionName: string;
-  collectionItems: string[];
-  tabs: {
-    name: string;
-    names?: LanguageSchemaFieldType;
-    collectionItems: string[];
-  }[];
-  backgroundColor: string;
-  textContent: string;
-  htmlContent: string;
-  canDel: boolean;
-}
-export interface IItemSchema extends Document {
-  widgetId: typeof Types.ObjectId;
-  title: string;
-  titles: LanguageSchemaFieldType;
-  subtitle: string;
-  subtitles: LanguageSchemaFieldType;
-  altText: string;
-  altTexts: LanguageSchemaFieldType;
-  link: string;
-  sequence: number;
-  itemType: ItemTypes;
-  img: any;
-  imgs: 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;
-  aggregations?: any[];
-  searchLimit?: number;
-};
-
-export type RedisConfig = {
-  HOST: string;
-  PORT: number;
-  PASSWORD?: string;
-  USER?: string;
-  DB?: number;
-};
-
-export interface IConfig {
-  logger: any;
-  catchAsync: (
-    fn: any,
-    modal?: string
-  ) => (req: any, res: any, next: any) => void;
-  getModals: (req: Express.Request) => Models;
-  collections: CollectionItem[];
-  customWidgetTypes: {
-    label: string;
-    value: string;
-    imageOnly?: boolean;
-    collectionsOnly?: boolean;
-  }[];
-  redis?: string | RedisConfig;
-  languages?: LanguageType[];
-}
-
-export type EntityType =
-  | IWidgetSchema
-  | IItemSchema
-  | IPageSchema
-  | ISrcSetSchema
-  | ITabSchema;
-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[];
-  tabs: { name: string; collectionItems: string[] }[];
-}
-export type IWidgetData = { [key: string]: IWidgetDataSchema };
-
-export type LanguageType = { code: string; name: string };

package/src/types/enums.ts

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

package/src/utils/defaults.ts

@@ -1,41 +0,0 @@
-import mongoose from 'mongoose';
-import { NextFunction } from 'express';
-import { CollectionItem, IConfig, IRequest, IResponse } from '../types';
-import { RESPONSE_CODES, internalServerError, validationError ,  REGEXS } from '../constants';
-
-export const defaults: IConfig = {
-  logger: console as any,
-  getModals: () => mongoose.models,
-  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!`;
-        } else if(message.match(REGEXS.IS_AVAILABLE)) {
-          return res.status(validationError).json({
-            code: RESPONSE_CODES.VALIDATION_FAILED,
-            message,
-            data: undefined,
-          });
-        }
-        // this.logger.error(err.message);
-        return res.status(internalServerError).json({
-          code: RESPONSE_CODES.ERROR,
-          message,
-          data: undefined,
-        });
-      });
-    },
-  collections: [] as CollectionItem[],
-  customWidgetTypes: [],
-  redis: undefined,
-  languages: [],
-};
-
-export const commonExcludedFields = {
-  __v: 0,
-  isDeleted: 0,
-  deletedAt: 0,
-};

package/src/utils/helper.ts

@@ -1,285 +0,0 @@
-import { model, Models, Schema, Types } from 'mongoose';
-import { commonExcludedFields, defaults } from './defaults';
-import {
-  IWidgetData,
-  IWidgetDataSchema,
-  IWidgetSchema,
-  SrcSetItem,
-} from '../types';
-
-export async function appendCollectionData(widgetData: IWidgetSchema[], models: Models) {
-  const { Widget }= models;
-  // 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,
-          tabs: widget.tabs,
-        };
-      }
-      return acc;
-    },
-    {}
-  );
-  if (Object.keys(newData).length > 0) {
-    const aggregationQueryCollectionItems = buildCollectionItemsQuery(newData);
-    if (aggregationQueryCollectionItems.length > 0) {
-      // getting collection data by populating widget
-      let aggregationData: any = await Widget.aggregate(
-        aggregationQueryCollectionItems
-      );
-      aggregationData = aggregationData.reduce((acc: any, aggregation: any) => {
-        acc[aggregation.code] = aggregation[aggregation.code];
-        return acc;
-      }, {});
-      // adding collection data to widgets
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      widgetData = widgetData.map((widget: IWidgetSchema) => {
-        if (aggregationData[widget.code]) {
-          return {
-            ...widget,
-            collectionItems: aggregationData[widget.code],
-          };
-        }
-        return widget;
-      });
-    }
-    const aggregationQueryTabs = buildTabCollectionItemsQuery(newData);
-    if (aggregationQueryTabs.length > 0) {
-      let aggregationDataTabs: any = await Widget.aggregate(
-        aggregationQueryTabs
-      );
-      aggregationDataTabs = aggregationDataTabs.reduce(
-        (acc: any, aggregation: any) => {
-          if (aggregation[aggregation.code])
-            acc[aggregation.code] = aggregation[aggregation.code];
-          return acc;
-        },
-        {}
-      );
-      // adding collection data to widgets
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-ignore
-      widgetData = widgetData.map((widget) => {
-        if (!aggregationDataTabs[widget.code]) return widget;
-        const collectionItemsObj = aggregationDataTabs[widget.code].reduce(
-          (acc: any, item: any) => {
-            acc[item._id] = item;
-            return acc;
-          },
-          {}
-        );
-        return {
-          ...widget,
-          tabs: widget.tabs.map((tabItem) => {
-            return {
-              name: tabItem.name,
-              names: tabItem.names,
-              collectionItems: tabItem.collectionItems
-                .map((collectionId) => collectionItemsObj[collectionId])
-                .filter(Boolean),
-            };
-          }),
-        };
-      });
-    }
-  }
-  // returning widget data as it is if they do not have dynamic collection
-  return widgetData;
-}
-
-function buildCollectionItemsQuery(formattedWidgetData: IWidgetData) {
-  const aggregationQuery: any = [
-    {
-      $match: {
-        _id: {
-          $in: Object.values(formattedWidgetData).map(
-            (item: IWidgetDataSchema) => item._id
-          ),
-        },
-      },
-    },
-    {
-      // Get only the fields that are not excluded
-      $project: {
-        _id: 1,
-        code: 1,
-      },
-    },
-  ];
-  let collectionConfig;
-  Object.keys(formattedWidgetData).forEach((key: string) => {
-    if (
-      formattedWidgetData[key].collectionItems &&
-      formattedWidgetData[key].collectionItems.length > 0
-    ) {
-      const aggregationQueryPiplelines: any[] = [];
-      collectionConfig = defaults.collections.find(
-        (c) => c.collectionName === formattedWidgetData[key].collectionName
-      );
-      if (
-        Array.isArray(collectionConfig?.aggregations) &&
-        collectionConfig?.aggregations.length
-      ) {
-        aggregationQueryPiplelines.push(...collectionConfig.aggregations);
-      }
-      const ids = formatCollectionItems(
-        formattedWidgetData[key].collectionItems
-      );
-      // Build piplelines with config
-      aggregationQueryPiplelines.push(
-        ...[
-          {
-            $match: {
-              _id: {
-                $in: ids,
-              },
-              ...(collectionConfig?.match || {}),
-            },
-          },
-          {
-            $project: {
-              ...commonExcludedFields,
-            },
-          },
-          { $addFields: { __order: { $indexOfArray: [ids, '$_id'] } } },
-          { $sort: { __order: 1 } },
-        ]
-      );
-      // Build Aggregation Query
-      aggregationQuery.push({
-        $lookup: {
-          from: formattedWidgetData[key].collectionName,
-          pipeline: aggregationQueryPiplelines,
-          as: formattedWidgetData[key].code,
-        },
-      });
-    }
-  });
-  return aggregationQuery;
-}
-
-function buildTabCollectionItemsQuery(formattedWidgetData: IWidgetData) {
-  const aggregationQuery: any = [
-    {
-      $match: {
-        _id: {
-          $in: Object.values(formattedWidgetData).map(
-            (item: IWidgetDataSchema) => item._id
-          ),
-        },
-      },
-    },
-    {
-      // Get only the fields that are not excluded
-      $project: {
-        _id: 1,
-        code: 1,
-      },
-    },
-  ];
-  let collectionConfig;
-  Object.keys(formattedWidgetData).forEach((key: string) => {
-    if (
-      formattedWidgetData[key].tabs &&
-      formattedWidgetData[key].tabs.length > 0
-    ) {
-      const aggregationQueryPiplelines: any[] = [];
-      collectionConfig = defaults.collections.find(
-        (c) => c.collectionName === formattedWidgetData[key].collectionName
-      );
-      if (
-        Array.isArray(collectionConfig?.aggregations) &&
-        collectionConfig?.aggregations.length
-      ) {
-        aggregationQueryPiplelines.push(...collectionConfig.aggregations);
-      }
-      // Build piplelines with config
-      aggregationQueryPiplelines.push(
-        ...[
-          {
-            $match: {
-              _id: {
-                $in: formattedWidgetData[key].tabs.reduce(
-                  (arr: Types.ObjectId[], tabItem) => {
-                    arr.push(...formatCollectionItems(tabItem.collectionItems));
-                    return arr;
-                  },
-                  []
-                ),
-              },
-              ...(collectionConfig?.match || {}),
-            },
-          },
-          {
-            $project: {
-              ...commonExcludedFields,
-            },
-          },
-        ]
-      );
-      // Build Aggregation Query
-      aggregationQuery.push({
-        $lookup: {
-          from: formattedWidgetData[key].collectionName,
-          pipeline: aggregationQueryPiplelines,
-          as: formattedWidgetData[key].code,
-        },
-      });
-    }
-  });
-  return aggregationQuery;
-}
-
-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(', ');
-      }
-    });
-  }
-}
-
-export const getCollectionModal = (collectionName: string, models: Models) => {
-  let collectionModal: any = models[collectionName];
-  if (!collectionModal) collectionModal = models[collectionName.charAt(0).toUpperCase() + collectionName.slice(1)]
-  if (!collectionModal) {
-    const schema = new Schema({}, { strict: false });
-    collectionModal = model(collectionName, schema, collectionName);
-  }
-  return collectionModal;
-};
-
-export const formatCollectionItems = (collectionItems: any[]) => {
-  if (Array.isArray(collectionItems) && collectionItems.length === 0) return [];
-
-  return collectionItems.map((item) => {
-    if (item instanceof Types.ObjectId) return item;
-    return new Types.ObjectId(item);
-  });
-};

package/src/utils/redis.ts

@@ -1,57 +0,0 @@
-import lz from 'lzutf8';
-import ioredis from 'ioredis';
-import { defaults } from './defaults';
-
-let redis: ioredis | null | undefined = null;
-
-const initRedis = () => {
-  if (defaults.redis && typeof defaults.redis === 'string') {
-    redis = new ioredis(defaults.redis);
-  } else if (defaults.redis && typeof defaults.redis === 'object') {
-    redis = new ioredis(
-      defaults.redis.PORT as number,
-      defaults.redis.HOST as string,
-      {
-        password: defaults.redis.PASSWORD,
-        username: defaults.redis.USER,
-        db: defaults.redis.DB,
-      }
-    );
-  } else redis = undefined;
-};
-
-export const getRedisValue = async (key: string) => {
-  if (redis === null) {
-    initRedis();
-  }
-  if (!redis) {
-    return null;
-  }
-  const value = await redis.get(key);
-  if (!value) {
-    return null;
-  }
-  const str = lz.decompress(lz.decodeBase64(value));
-  return JSON.parse(str);
-};
-
-export const setRedisValue = async (key: string, value: JSON) => {
-  if (redis === null) {
-    initRedis();
-  }
-  if (!redis) {
-    return null;
-  }
-  const compressed = lz.encodeBase64(lz.compress(JSON.stringify(value)));
-  return await redis.set(key, compressed);
-};
-
-export const deleteRedisValue = async (key: string) => {
-  if (redis === null) {
-    initRedis();
-  }
-  if (!redis) {
-    return null;
-  }
-  return await redis.del(key);
-};