@evershop/evershop 2.1.1 → 2.1.2

package/src/modules/catalog/services/attribute/updateProductAttribute.ts

@@ -10,8 +10,9 @@ import {
   insert
 } from '@evershop/postgres-query-builder';
 import { getConnection } from '../../../../lib/postgres/connection.js';
-import { hookable } from '../../../../lib/util/hookable.js';
+import { hookable, hookBefore, hookAfter } from '../../../../lib/util/hookable.js';
 import { getValueSync, getValue } from '../../../../lib/util/registry.js';
+import type { AttributeRow } from '../../../../types/db/index.js';
 import { getAjv } from '../../../base/services/getAjv.js';
 import attributeDataSchema from './attributeDataSchema.json' with { type: 'json' };
 
@@ -20,10 +21,10 @@ export type AttributeData = {
   type?: string;
   groups: number[];
   options: { option_text: string, option_id: string | number }[];
-  [key: string]: any;
+  [key: string]: unknown;
 };
 
-function validateAttributeDataBeforeInsert(data: AttributeData) {
+function validateAttributeDataBeforeInsert(data: AttributeData): AttributeData {
   const ajv = getAjv();
   attributeDataSchema.required = [];
   const jsonSchema = getValueSync(
@@ -46,7 +47,7 @@ async function updateAttributeOptions(
   attributeCode: string,
   options: { option_text: string, option_id: string | number }[],
   connection: PoolClient
-) {
+): Promise<void> {
   // Ignore updating options if it is not present in the data or if the attribute type is not select or multiselect
   if (
     !['select', 'multiselect'].includes(attributeType)
@@ -101,7 +102,7 @@ async function updateAttributeOptions(
   );
 }
 
-async function updateAttributeGroups(attributeId: number, groups: number[], connection: PoolClient) {
+async function updateAttributeGroups(attributeId: number, groups: number[], connection: PoolClient): Promise<void> {
   // Ignore updating groups if it is not present in the data
   if (groups.length === 0) {
     return;
@@ -140,7 +141,7 @@ async function updateAttributeGroups(attributeId: number, groups: number[], conn
     .execute(connection);
 }
 
-async function updateAttributeData(uuid: string, data: AttributeData, connection: PoolClient) {
+async function updateAttributeData(uuid: string, data: AttributeData, connection: PoolClient): Promise<AttributeRow & { updatedId?: number }> {
   const attribute = await select()
     .from('attribute')
     .where('uuid', '=', uuid)
@@ -150,18 +151,17 @@ async function updateAttributeData(uuid: string, data: AttributeData, connection
     throw new Error('Requested attribute not found');
   }
   try {
-    const attribute = await update('attribute')
+    const updatedAttribute = await update('attribute')
       .given(data)
       .where('uuid', '=', uuid)
       .execute(connection);
-    return attribute;
+    Object.assign(attribute, updatedAttribute);
   } catch (e) {
     if (!e.message.includes('No data was provided')) {
       throw e;
-    } else {
-      return attribute;
     }
   }
+  return attribute;
 }
 
 /**
@@ -170,7 +170,7 @@ async function updateAttributeData(uuid: string, data: AttributeData, connection
  * @param {Object} data
  * @param {Object} context
  */
-async function updateAttribute(uuid: string, data: AttributeData, context: Record<string, any>) {
+async function updateAttribute(uuid: string, data: AttributeData, context: Record<string, any>): Promise<AttributeRow & { updatedId?: number }> {
   const connection = await getConnection();
   await startTransaction(connection);
   try {
@@ -222,7 +222,7 @@ async function updateAttribute(uuid: string, data: AttributeData, context: Recor
  * @param {Object} data
  * @param {Object} context
  */
-export default async (uuid: string, data: AttributeData, context: Record<string, any>) => {
+export default async (uuid: string, data: AttributeData, context: Record<string, any>): Promise<AttributeRow & { updatedId?: number }> => {
   // Make sure the context is either not provided or is an object
   if (context && typeof context !== 'object') {
     throw new Error('Context must be an object');
@@ -234,3 +234,119 @@ export default async (uuid: string, data: AttributeData, context: Record<string,
   );
   return attribute;
 };
+
+export function hookBeforeUpdateAttributeData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: AttributeData,
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateAttributeData', callback, priority);
+}
+
+export function hookAfterUpdateAttributeData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: AttributeData,
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateAttributeData', callback, priority);
+}
+
+export function hookBeforeUpdateAttributeGroups(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    attributeId: number,
+    groups: number[],
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateAttributeGroups', callback, priority);
+}
+
+export function hookAfterUpdateAttributeGroups(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    attributeId: number,
+    groups: number[],
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateAttributeGroups', callback, priority);
+}
+
+export function hookBeforeUpdateAttributeOptions(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    attributeId: number,
+    attributeType: string,
+    attributeCode: string,
+    options: { option_text: string; option_id: string | number }[],
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateAttributeOptions', callback, priority);
+}
+
+export function hookAfterUpdateAttributeOptions(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    attributeId: number,
+    attributeType: string,
+    attributeCode: string,
+    options: { option_text: string; option_id: string | number }[],
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateAttributeOptions', callback, priority);
+}
+
+export function hookBeforeUpdateAttribute(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: AttributeData,
+    context: Record<string, any>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateAttribute', callback, priority);
+}
+
+export function hookAfterUpdateAttribute(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: AttributeData,
+    context: Record<string, any>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateAttribute', callback, priority);
+}

package/src/modules/catalog/services/category/createCategory.ts

@@ -1,3 +1,4 @@
+import { Row } from '@components/common/form/Editor.js';
 import {
   commit,
   insert,
@@ -8,21 +9,24 @@ import {
 import type { PoolClient } from '@evershop/postgres-query-builder';
 import { JSONSchemaType } from 'ajv';
 import { getConnection } from '../../../../lib/postgres/connection.js';
-import { hookable } from '../../../../lib/util/hookable.js';
+import { hookable, hookBefore, hookAfter } from '../../../../lib/util/hookable.js';
 import {
   getValue,
   getValueSync
 } from '../../../../lib/util/registry.js';
+import { sanitizeRawHtml } from '../../../../lib/util/sanitizeHtml.js';
+import type { CategoryDescriptionRow, CategoryRow } from '../../../../types/db/index.js';
 import { getAjv } from '../../../base/services/getAjv.js';
 import categoryDataSchema from './categoryDataSchema.json' with { type: 'json' };
 
 export type CategoryData = {
   name: string;
   url_key: string;
-  [key: string]: any;
+  description?: Row[];
+  [key: string]: unknown;
 };
 
-function validateCategoryDataBeforeInsert(data: CategoryData) {
+function validateCategoryDataBeforeInsert(data: CategoryData): CategoryData {
   const ajv = getAjv();
   (categoryDataSchema as JSONSchemaType<any>).required = ['name', 'url_key'];
   const jsonSchema = getValueSync(
@@ -39,7 +43,7 @@ function validateCategoryDataBeforeInsert(data: CategoryData) {
   }
 }
 
-async function insertCategoryData(data: CategoryData & { parent_id?: number }, connection: PoolClient) {
+async function insertCategoryData(data: CategoryData & { parent_id?: number }, connection: PoolClient): Promise<CategoryRow & CategoryDescriptionRow & { insertId: number }> {
   const parentId = data.parent_id;
   if (parentId) {
     // Load the parent category
@@ -70,7 +74,7 @@ async function insertCategoryData(data: CategoryData & { parent_id?: number }, c
  * @param {Object} data
  * @param {Object} context
  */
-async function createCategory(data: CategoryData, context: Record<string, any>) {
+async function createCategory(data: CategoryData, context: Record<string, any>): Promise<CategoryRow & CategoryDescriptionRow & { insertId: number }> {
   const connection = await getConnection();
   await startTransaction(connection);
   try {
@@ -78,6 +82,10 @@ async function createCategory(data: CategoryData, context: Record<string, any>)
     // Validate category data
     validateCategoryDataBeforeInsert(categoryData);
 
+    // Sanitize raw HTML blocks in EditorJS content
+    if (categoryData.description) {
+      sanitizeRawHtml(categoryData.description);
+    }
     // Insert category data
     const category = await hookable(insertCategoryData, context)(
       categoryData,
@@ -97,7 +105,7 @@ async function createCategory(data: CategoryData, context: Record<string, any>)
  * @param {Object} data
  * @param {Object} context
  */
-export default async (data: CategoryData, context: Record<string, any>) => {
+export default async (data: CategoryData, context: Record<string, any>): Promise<CategoryRow & CategoryDescriptionRow & { insertId: number }> => {
   // Make sure the context is either not provided or is an object
   if (context && typeof context !== 'object') {
     throw new Error('Context must be an object');
@@ -105,3 +113,55 @@ export default async (data: CategoryData, context: Record<string, any>) => {
   const category = await hookable(createCategory, context)(data, context);
   return category;
 };
+
+export function hookBeforeInsertCategoryData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    data: CategoryData & { parent_id?: number },
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('insertCategoryData', callback, priority);
+}
+
+export function hookAfterInsertCategoryData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    data: CategoryData & { parent_id?: number },
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('insertCategoryData', callback, priority);
+}
+
+export function hookBeforeCreateCategory(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    data: CategoryData,
+    context: Record<string, any>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('createCategory', callback, priority);
+}
+
+export function hookAfterCreateCategory(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    data: CategoryData,
+    context: Record<string, any>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('createCategory', callback, priority);
+}

package/src/modules/catalog/services/category/deleteCategory.ts

@@ -7,9 +7,20 @@ import {
 } from '@evershop/postgres-query-builder';
 import type { PoolClient } from '@evershop/postgres-query-builder';
 import { getConnection } from '../../../../lib/postgres/connection.js';
-import { hookable } from '../../../../lib/util/hookable.js';
+import {
+  hookable,
+  hookBefore,
+  hookAfter
+} from '../../../../lib/util/hookable.js';
+import type {
+  CategoryDescriptionRow,
+  CategoryRow
+} from '../../../../types/db/index.js';
 
-async function deleteCategoryData(uuid: string, connection: PoolClient) {
+async function deleteCategoryData(
+  uuid: string,
+  connection: PoolClient
+): Promise<void> {
   await del('category').where('uuid', '=', uuid).execute(connection);
 }
 /**
@@ -17,7 +28,10 @@ async function deleteCategoryData(uuid: string, connection: PoolClient) {
  * @param {String} uuid
  * @param {Object} context
  */
-async function deleteCategory(uuid: string, context: Record<string, any>) {
+async function deleteCategory(
+  uuid: string,
+  context: Record<string, any>
+): Promise<CategoryRow & CategoryDescriptionRow> {
   const connection = await getConnection();
   await startTransaction(connection);
   try {
@@ -53,7 +67,10 @@ async function deleteCategory(uuid: string, context: Record<string, any>) {
  * @param {String} uuid
  * @param {Object} context
  */
-export default async (uuid: string, context: Record<string, any>) => {
+export default async (
+  uuid: string,
+  context: Record<string, any>
+): Promise<CategoryRow & CategoryDescriptionRow> => {
   // Make sure the context is either not provided or is an object
   if (context && typeof context !== 'object') {
     throw new Error('Context must be an object');
@@ -61,3 +78,43 @@ export default async (uuid: string, context: Record<string, any>) => {
   const category = await hookable(deleteCategory, context)(uuid, context);
   return category;
 };
+
+export function hookBeforeDeleteCategoryData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteCategoryData', callback, priority);
+}
+
+export function hookAfterDeleteCategoryData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteCategoryData', callback, priority);
+}
+
+export function hookBeforeDeleteCategory(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteCategory', callback, priority);
+}
+
+export function hookAfterDeleteCategory(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteCategory', callback, priority);
+}

package/src/modules/catalog/services/category/updateCategory.ts

@@ -6,19 +6,20 @@ import {
   update
 } from '@evershop/postgres-query-builder';
 import type { PoolClient } from '@evershop/postgres-query-builder';
-import { JSONSchemaType } from 'ajv';
 import { getConnection } from '../../../../lib/postgres/connection.js';
-import { hookable } from '../../../../lib/util/hookable.js';
+import { hookable, hookBefore, hookAfter } from '../../../../lib/util/hookable.js';
 import {
   getValue,
   getValueSync
 } from '../../../../lib/util/registry.js';
+import { sanitizeRawHtml } from '../../../../lib/util/sanitizeHtml.js';
+import type { CategoryDescriptionRow, CategoryRow } from '../../../../types/db/index.js';
 import { getAjv } from '../../../base/services/getAjv.js';
 import categoryDataSchema from './categoryDataSchema.json' with { type: 'json' };
 import { CategoryData } from './createCategory.js';
 
 
-function validateCategoryDataBeforeInsert(data: CategoryData) {
+function validateCategoryDataBeforeInsert(data: CategoryData): CategoryData {
   const ajv = getAjv();
   categoryDataSchema.required = [];
   const jsonSchema = getValueSync(
@@ -35,7 +36,7 @@ function validateCategoryDataBeforeInsert(data: CategoryData) {
   }
 }
 
-async function updateCategoryData(uuid: string, data: CategoryData, connection: PoolClient) {
+async function updateCategoryData(uuid: string, data: CategoryData, connection: PoolClient): Promise<CategoryRow & CategoryDescriptionRow & { updatedId?: number }> {
   const query = select().from('category');
   query
     .leftJoin('category_description')
@@ -48,9 +49,9 @@ async function updateCategoryData(uuid: string, data: CategoryData, connection:
   if (!category) {
     throw new Error('Requested category not found');
   }
-
+  let newCategory;
   try {
-    const newCategory = await update('category')
+    newCategory = await update('category')
       .given(data)
       .where('uuid', '=', uuid)
       .execute(connection);
@@ -60,8 +61,9 @@ async function updateCategoryData(uuid: string, data: CategoryData, connection:
       throw e;
     }
   }
+  let description;
   try {
-    const description = await update('category_description')
+     description = await update('category_description')
       .given(data)
       .where('category_description_category_id', '=', category.category_id)
       .execute(connection);
@@ -72,7 +74,11 @@ async function updateCategoryData(uuid: string, data: CategoryData, connection:
     }
   }
 
-  return category;
+  return {
+    ...description,
+    ...newCategory,
+    updatedId: category.category_id
+  };
 }
 
 /**
@@ -81,7 +87,7 @@ async function updateCategoryData(uuid: string, data: CategoryData, connection:
  * @param {Object} data
  * @param {Object} context
  */
-async function updateCategory(uuid: string, data: CategoryData, context: Record<string, any>) {
+async function updateCategory(uuid: string, data: CategoryData, context: Record<string, any>): Promise<CategoryRow & CategoryDescriptionRow & { updatedId?: number }> {
   const connection = await getConnection();
   await startTransaction(connection);
   try {
@@ -89,6 +95,9 @@ async function updateCategory(uuid: string, data: CategoryData, context: Record<
     // Validate category data
     validateCategoryDataBeforeInsert(categoryData);
 
+    if (categoryData.description) {
+      sanitizeRawHtml(categoryData.description);
+    }
     // Insert category data
     const category = await hookable(updateCategoryData, {
       ...context,
@@ -109,7 +118,7 @@ async function updateCategory(uuid: string, data: CategoryData, context: Record<
  * @param {Object} data
  * @param {Object} context
  */
-export default async (uuid: string, data: CategoryData, context: Record<string, any>) => {
+export default async (uuid: string, data: CategoryData, context: Record<string, any>): Promise<CategoryRow & CategoryDescriptionRow & { updatedId?: number }> => {
   // Make sure the context is either not provided or is an object
   if (context && typeof context !== 'object') {
     throw new Error('Context must be an object');
@@ -117,3 +126,59 @@ export default async (uuid: string, data: CategoryData, context: Record<string,
   const category = await hookable(updateCategory, context)(uuid, data, context);
   return category;
 };
+
+export function hookBeforeUpdateCategoryData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: CategoryData,
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateCategoryData', callback, priority);
+}
+
+export function hookAfterUpdateCategoryData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: CategoryData,
+    connection: PoolClient
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateCategoryData', callback, priority);
+}
+
+export function hookBeforeUpdateCategory(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: CategoryData,
+    context: Record<string, any>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateCategory', callback, priority);
+}
+
+export function hookAfterUpdateCategory(
+  callback: (
+    this: Record<string, any>,
+    ...args: [
+    uuid: string,
+    data: CategoryData,
+    context: Record<string, any>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateCategory', callback, priority);
+}