@knovator/pagecreator-node 1.1.8 → 1.2.0

package/src/index.ts

@@ -0,0 +1,59 @@
+import { defaults } from './utils/defaults';
+import WidgetRoutes from './routes/WidgetRoute';
+import PageRoutes from './routes/PageRoute';
+import UserRoutes from './routes/UserRoute';
+import {
+  Widget,
+  Item,
+  Page,
+  Tab,
+  SrcSet,
+  WidgetSchema,
+  ItemSchema,
+  PageSchema,
+  SrcSetSchema,
+  TabSchema,
+} from './models';
+import { IConfig } from './types';
+import { handleUpdateData, handleResetData } from './services/dataService';
+
+function setConfig(config: Partial<IConfig>) {
+  if (config.logger) {
+    defaults.logger = config.logger;
+  }
+  if (typeof config.catchAsync === 'function')
+    defaults.catchAsync = config.catchAsync;
+  if (typeof config.getModals === 'function')
+    defaults.getModals = config.getModals;
+  if (Array.isArray(config.collections)) {
+    defaults.collections = config.collections;
+  }
+  if (Array.isArray(config.customWidgetTypes)) {
+    defaults.customWidgetTypes = config.customWidgetTypes;
+  }
+  if (typeof config.redis === 'string' || typeof config.redis === 'object') {
+    defaults.redis = config.redis;
+  }
+  if (Array.isArray(config.languages) && config.languages.length > 0) {
+    defaults.languages = config.languages;
+  }
+}
+
+export {
+  WidgetRoutes,
+  PageRoutes,
+  UserRoutes,
+  Widget,
+  Item,
+  Page,
+  Tab,
+  SrcSet,
+  WidgetSchema,
+  ItemSchema,
+  PageSchema,
+  SrcSetSchema,
+  TabSchema,
+  setConfig,
+  handleResetData,
+  handleUpdateData,
+};

package/src/models/Item.ts

@@ -0,0 +1,53 @@
+import { Schema, Types, model } from 'mongoose';
+import mongoosePaginate from 'mongoose-paginate-v2';
+import { softDeletePlugin } from '../plugins/softDelete';
+import { IModel, IItemSchema, ItemTypes } from '../types';
+import { defaults } from '../utils/defaults';
+
+const titlesSchema =
+  defaults.languages?.reduce((acc: any, lang) => {
+    acc[lang.code] = { type: String, required: true };
+    return acc;
+  }, {}) || {};
+
+const imagesSchema =
+  defaults.languages?.reduce((acc: any, lang) => {
+    acc[lang.code] = { type: Schema.Types.ObjectId, ref: 'file' };
+    return acc;
+  }, {}) || {};
+
+const altTextsSchema =
+  defaults.languages?.reduce((acc: any, lang) => {
+    acc[lang.code] = { type: String };
+    return acc;
+  }, {}) || {};
+
+const ItemSchema = new Schema<IItemSchema>({
+  widgetId: {
+    type: Types.ObjectId,
+    ref: 'Widget',
+  },
+  title: String,
+  titles: titlesSchema,
+  subtitle: String,
+  subtitles: titlesSchema,
+  altText: String,
+  altTexts: altTextsSchema,
+  link: String,
+  sequence: Number,
+  img: { type: Schema.Types.ObjectId, ref: 'file' },
+  imgs: imagesSchema,
+  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 { Item, ItemSchema };

package/src/models/Page.ts

@@ -0,0 +1,22 @@
+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,
+  slug: String,
+  canDel: {
+    type: Boolean,
+    default: true,
+  },
+  widgets: [{ type: Types.ObjectId, ref: 'Widget' }],
+});
+
+PageSchema.plugin(softDeletePlugin);
+PageSchema.plugin(mongoosePaginate);
+
+const Page = model('Page', PageSchema) as unknown as IModel<IPageSchema>;
+
+export { Page, PageSchema };

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 { SrcSet, SrcSetSchema };

package/src/models/Tab.ts

@@ -0,0 +1,28 @@
+import { Schema, model, Types } from 'mongoose';
+import mongoosePaginate from 'mongoose-paginate-v2';
+import { softDeletePlugin } from '../plugins/softDelete';
+import { IModel, ITabSchema } from '../types';
+import { defaults } from '../utils/defaults';
+
+const namesSchema =
+  defaults.languages?.reduce((acc: any, lang) => {
+    acc[lang.code] = { type: String, required: true };
+    return acc;
+  }, {}) || {};
+
+const TabSchema = new Schema<ITabSchema>({
+  name: String,
+  names: namesSchema,
+  widgetId: {
+    type: Types.ObjectId,
+    ref: 'Widget',
+  },
+  collectionItems: [{ type: Types.ObjectId }],
+});
+
+TabSchema.plugin(softDeletePlugin);
+TabSchema.plugin(mongoosePaginate);
+
+const Tab = model('Tab', TabSchema) as unknown as IModel<ITabSchema>;
+
+export { Tab, TabSchema };

package/src/models/Widget.ts

@@ -0,0 +1,65 @@
+import { Schema, model, Types } from 'mongoose';
+import mongoosePaginate from 'mongoose-paginate-v2';
+import { softDeletePlugin } from '../plugins/softDelete';
+import { IModel, IWidgetSchema, WidgetTypes, ItemsType } from '../types';
+import { defaults } from '../utils/defaults';
+
+const languageTitlesSchema =
+  defaults.languages?.reduce((acc: any, lang) => {
+    acc[lang.code] = { type: String, required: true };
+    return acc;
+  }, {}) || {};
+
+const WidgetSchema = new Schema<IWidgetSchema>({
+  name: String,
+  code: String,
+  autoPlay: {
+    type: Boolean,
+    default: false,
+  },
+  isActive: {
+    type: Boolean,
+    default: true,
+  },
+  widgetTitle: String,
+  widgetTitles: languageTitlesSchema,
+  webPerRow: Number,
+  mobilePerRow: Number,
+  tabletPerRow: Number,
+  collectionName: String,
+  backgroundColor: String,
+  collectionItems: [{ type: Types.ObjectId, refPath: 'collectionName' }],
+  itemsType: {
+    type: String,
+    default: ItemsType.Image,
+    required: true,
+  },
+  widgetType: {
+    type: String,
+    default: WidgetTypes.FixedCard,
+    required: true,
+  },
+  tabs: [
+    {
+      name: String,
+      names: languageTitlesSchema,
+      collectionItems: [{ type: Types.ObjectId, refPath: 'collectionName' }],
+    },
+  ],
+  canDel: {
+    type: Boolean,
+    default: true,
+  },
+  textContent: {type: String},
+  htmlContent: {type: String}
+});
+
+WidgetSchema.plugin(softDeletePlugin);
+WidgetSchema.plugin(mongoosePaginate);
+
+const Widget = model(
+  'Widget',
+  WidgetSchema
+) as unknown as IModel<IWidgetSchema>;
+
+export { Widget, WidgetSchema };

package/src/models/{index.d.ts → index.ts}

@@ -3,4 +3,16 @@ import { Item, ItemSchema } from './Item';
 import { Page, PageSchema } from './Page';
 import { SrcSet, SrcSetSchema } from './SrcSet';
 import { Tab, TabSchema } from './Tab';
-export { Widget, Item, Page, SrcSet, Tab, WidgetSchema, ItemSchema, PageSchema, SrcSetSchema, TabSchema, };
+
+export {
+  Widget,
+  Item,
+  Page,
+  SrcSet,
+  Tab,
+  WidgetSchema,
+  ItemSchema,
+  PageSchema,
+  SrcSetSchema,
+  TabSchema,
+};

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/PageRoute.ts

@@ -0,0 +1,30 @@
+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,77 @@
+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 tabValidation from '../utils/validations/tab';
+import * as widgetValidation from '../utils/validations/widget';
+import * as widgetController from '../controllers/WidgetController';
+import * as tabController from '../controllers/TabController';
+
+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`);
+// Tabs
+routes
+  .post('/tabs', validate(tabValidation.create), tabController.createTab)
+  .descriptor(`${descriptorPrefix}tab.create`);
+routes
+  .put('/tabs/:tabId', validate(tabValidation.update), tabController.updateTab)
+  .descriptor(`${descriptorPrefix}tab.update`);
+routes
+  .delete('/tabs/:tabId', tabController.deleteTab)
+  .descriptor(`${descriptorPrefix}tab.delete`);
+routes
+  .get('/tabs/:widgetId', tabController.getTabs)
+  .descriptor(`${descriptorPrefix}tab.getAll`);
+// Get all languages
+routes.get(`/languages`, widgetController.getLanguages);
+// Get single widget
+routes
+  .get(`/:id`, widgetController.getSingleWidget)
+  .descriptor(`${descriptorPrefix}widget.getOne`);
+    
+export default routes;