@evershop/evershop 2.1.1 → 2.1.2

package/src/modules/catalog/services/collection/createCollection.ts

@@ -5,38 +5,27 @@ import {
   insert
 } 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 { getValueSync, getValue } from '../../../../lib/util/registry.js';
-import { getAjv } from '../../../base/services/getAjv.js';
-import collectionDataSchema from './collectionDataSchema.json' with { type: 'json' };
+import {
+  hookable,
+  hookBefore,
+  hookAfter
+} from '../../../../lib/util/hookable.js';
+import { getValue } from '../../../../lib/util/registry.js';
+import { Row, sanitizeRawHtml } from '../../../../lib/util/sanitizeHtml.js';
+import type { CollectionRow } from '../../../../types/db/index.js';
 
 export type CollectionData = {
   name: string;
-  description: string;
   code: string;
-  [key: string]: any;
+  description?: Row[];
+  [key: string]: unknown;
 };
 
-function validateCollectionDataBeforeInsert(data: CollectionData) {
-  const ajv = getAjv();
-  (collectionDataSchema as JSONSchemaType<any>).required = ['name', 'description', 'code'];
-  const jsonSchema = getValueSync(
-    'createCollectionDataJsonSchema',
-    collectionDataSchema,
-    {}
-  );
-  const validate = ajv.compile(jsonSchema);
-  const valid = validate(data);
-  if (valid) {
-    return data;
-  } else {
-    throw new Error(validate.errors[0].message);
-  }
-}
-
-async function insertCollectionData(data: CollectionData, connection: PoolClient) {
+async function insertCollectionData(
+  data: CollectionData,
+  connection: PoolClient
+): Promise<CollectionRow & { insertId: number }> {
   const collection = await insert('collection').given(data).execute(connection);
   return collection;
 }
@@ -46,14 +35,23 @@ async function insertCollectionData(data: CollectionData, connection: PoolClient
  * @param {Object} data
  * @param {Object} context
  */
-async function createCollection(data: CollectionData, context: Record<string, any>) {
+async function createCollection(
+  data: CollectionData,
+  context: Record<string, any>
+): Promise<CollectionRow & { insertId: number }> {
   const connection = await getConnection();
   await startTransaction(connection);
   const hookContext = { connection, ...context };
   try {
-    const collectionData = await getValue('collectionDataBeforeCreate', data);
-    // Validate collection data
-    validateCollectionDataBeforeInsert(collectionData);
+    const collectionData = await getValue<CollectionData>(
+      'collectionDataBeforeCreate',
+      data,
+      {}
+    );
+    // Sanitize raw HTML blocks in EditorJS content
+    if (collectionData.description) {
+      sanitizeRawHtml(collectionData.description);
+    }
 
     // Insert collection data
     const collection = await hookable(insertCollectionData, hookContext)(
@@ -74,7 +72,10 @@ async function createCollection(data: CollectionData, context: Record<string, an
  * @param {Object} data
  * @param {Object} context
  */
-export default async (data: CollectionData, context: Record<string, any>) => {
+export default async (
+  data: CollectionData,
+  context: Record<string, any>
+): Promise<CollectionRow & { 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');
@@ -82,3 +83,43 @@ export default async (data: CollectionData, context: Record<string, any>) => {
   const collection = await hookable(createCollection)(data, context);
   return collection;
 };
+
+export function hookBeforeInsertCollectionData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: CollectionData, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('insertCollectionData', callback, priority);
+}
+
+export function hookAfterInsertCollectionData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: CollectionData, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('insertCollectionData', callback, priority);
+}
+
+export function hookBeforeCreateCollection(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: CollectionData, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('createCollection', callback, priority);
+}
+
+export function hookAfterCreateCollection(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: CollectionData, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('createCollection', callback, priority);
+}

package/src/modules/catalog/services/collection/deleteCollection.ts

@@ -7,9 +7,17 @@ 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 { CollectionRow } from '../../../../types/db/index.js';
 
-async function deleteCollectionData(uuid: string, connection: PoolClient) {
+async function deleteCollectionData(
+  uuid: string,
+  connection: PoolClient
+): Promise<void> {
   await del('collection').where('uuid', '=', uuid).execute(connection);
 }
 /**
@@ -17,7 +25,10 @@ async function deleteCollectionData(uuid: string, connection: PoolClient) {
  * @param {String} uuid
  * @param {Object} context
  */
-async function deleteCollection(uuid: string, context: Record<string, any>) {
+async function deleteCollection(
+  uuid: string,
+  context: Record<string, any>
+): Promise<CollectionRow> {
   const connection = await getConnection();
   await startTransaction(connection);
   try {
@@ -45,7 +56,10 @@ async function deleteCollection(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<CollectionRow> => {
   // 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');
@@ -53,3 +67,43 @@ export default async (uuid: string, context: Record<string, any>) => {
   const collection = await hookable(deleteCollection, context)(uuid, context);
   return collection;
 };
+
+export function hookBeforeDeleteCollectionData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteCollectionData', callback, priority);
+}
+
+export function hookAfterDeleteCollectionData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteCollectionData', callback, priority);
+}
+
+export function hookBeforeDeleteCollection(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteCollection', callback, priority);
+}
+
+export function hookAfterDeleteCollection(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteCollection', callback, priority);
+}

package/src/modules/catalog/services/collection/updateCollection.ts

@@ -1,4 +1,4 @@
-import {  
+import {
   commit,
   rollback,
   select,
@@ -6,35 +6,22 @@ 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 {
-  getValue,
-  getValueSync
-} from '../../../../lib/util/registry.js';
-import { getAjv } from '../../../base/services/getAjv.js';
-import collectionDataSchema from './collectionDataSchema.json' with { type: 'json' };
+  hookable,
+  hookBefore,
+  hookAfter
+} from '../../../../lib/util/hookable.js';
+import { getValue } from '../../../../lib/util/registry.js';
+import { sanitizeRawHtml } from '../../../../lib/util/sanitizeHtml.js';
+import type { CollectionRow } from '../../../../types/db/index.js';
 import { CollectionData } from './createCollection.js';
 
-function validateCollectionDataBeforeInsert(data: CollectionData) {
-  const ajv = getAjv();
-  (collectionDataSchema as JSONSchemaType<any>).required = [];
-  const jsonSchema = getValueSync(
-    'updateCollectionDataJsonSchema',
-    collectionDataSchema,
-    {}
-  );
-  const validate = ajv.compile(jsonSchema);
-  const valid = validate(data);
-  if (valid) {
-    return data;
-  } else {
-    throw new Error(validate.errors[0].message);
-  }
-}
-
-async function updateCollectionData(uuid: string, data: CollectionData, connection: PoolClient) {
+async function updateCollectionData(
+  uuid: string,
+  data: CollectionData,
+  connection: PoolClient
+): Promise<CollectionRow & { updatedId?: number }> {
   const collection = await select()
     .from('collection')
     .where('uuid', '=', uuid)
@@ -49,15 +36,13 @@ async function updateCollectionData(uuid: string, data: CollectionData, connecti
       .given(data)
       .where('uuid', '=', uuid)
       .execute(connection);
-
-    return newCollection;
+    Object.assign(collection, newCollection);
   } catch (e) {
     if (!e.message.includes('No data was provided')) {
       throw e;
-    } else {
-      return collection;
     }
   }
+  return collection;
 }
 
 /**
@@ -66,16 +51,22 @@ async function updateCollectionData(uuid: string, data: CollectionData, connecti
  * @param {Object} data
  * @param {Object} context
  */
-async function updateCollection(uuid: string, data: CollectionData, context: Record<string, any>) {
+async function updateCollection(
+  uuid: string,
+  data: CollectionData,
+  context: Record<string, any>
+): Promise<CollectionRow & { updatedId?: number }> {
   const connection = await getConnection();
   await startTransaction(connection);
   const hookContext = { connection, ...context };
   try {
     const collectionData = await getValue('collectionDataBeforeUpdate', data);
-    // Validate collection data
-    validateCollectionDataBeforeInsert(collectionData);
+    // Sanitize raw HTML blocks in EditorJS content
+    if (collectionData.description) {
+      sanitizeRawHtml(collectionData.description);
+    }
 
-    // Insert collection data
+    // Update collection data
     const collection = await hookable(updateCollectionData, hookContext)(
       uuid,
       collectionData,
@@ -95,7 +86,11 @@ async function updateCollection(uuid: string, data: CollectionData, context: Rec
  * @param {Object} data
  * @param {Object} context
  */
-export default async (uuid: string, data: CollectionData, context: Record<string, any>) => {
+export default async (
+  uuid: string,
+  data: CollectionData,
+  context: Record<string, any>
+): Promise<CollectionRow & { 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');
@@ -108,3 +103,43 @@ export default async (uuid: string, data: CollectionData, context: Record<string
   );
   return collection;
 };
+
+export function hookBeforeUpdateCollectionData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: CollectionData, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateCollectionData', callback, priority);
+}
+
+export function hookAfterUpdateCollectionData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: CollectionData, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateCollectionData', callback, priority);
+}
+
+export function hookBeforeUpdateCollection(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: CollectionData, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateCollection', callback, priority);
+}
+
+export function hookAfterUpdateCollection(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: CollectionData, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateCollection', callback, priority);
+}

package/src/modules/catalog/services/index.ts

@@ -1,37 +1,48 @@
-import createAttribute from './attribute/createProductAttribute.js';
-import deleteAttribute from './attribute/deleteProductAttribute.js';
-import updateAttribute from './attribute/updateProductAttribute.js';
-import createCategory from './category/createCategory.js';
-import deleteCategory from './category/deleteCategory.js';
-import updateCategory from './category/updateCategory.js';
-import createCollection from './collection/createCollection.js';
-import deleteCollection from './collection/deleteCollection.js';
-import updateCollection from './collection/updateCollection.js';
-import { getCategoriesBaseQuery } from './getCategoriesBaseQuery.js';
-import { getCollectionsBaseQuery } from './getCollectionsBaseQuery.js';
-import { getProductsBaseQuery } from './getProductsBaseQuery.js';
-import { getProductsByCategoryBaseQuery } from './getProductsByCategoryBaseQuery.js';
-import { getProductsByCollectionBaseQuery } from './getProductsByCollectionBaseQuery.js';
-import createProduct from './product/createProduct.js';
-import deleteProduct from './product/deleteProduct.js';
-import updateProduct from './product/updateProduct.js';
+// Products
+export { default as createProduct } from './product/createProduct.js';
+export * from './product/createProduct.js';
+export { default as updateProduct } from './product/updateProduct.js';
+export * from './product/updateProduct.js';
+export { default as deleteProduct } from './product/deleteProduct.js';
+export * from './product/deleteProduct.js';
 
+// Categories
+export { default as createCategory } from './category/createCategory.js';
+export * from './category/createCategory.js';
+export { default as updateCategory } from './category/updateCategory.js';
+export * from './category/updateCategory.js';
+export { default as deleteCategory } from './category/deleteCategory.js';
+export * from './category/deleteCategory.js';
+
+// Collections
+export { default as createCollection } from './collection/createCollection.js';
+export * from './collection/createCollection.js';
+export { default as updateCollection } from './collection/updateCollection.js';
+export * from './collection/updateCollection.js';
+export { default as deleteCollection } from './collection/deleteCollection.js';
+export * from './collection/deleteCollection.js';
+
+// Attributes
+// AttributeData is exported from createProductAttribute only to avoid name conflict
+export { default as createAttribute } from './attribute/createProductAttribute.js';
+export * from './attribute/createProductAttribute.js';
+export { default as updateAttribute } from './attribute/updateProductAttribute.js';
 export {
-  createProduct,
-  updateProduct,
-  deleteProduct,
-  createCollection,
-  updateCollection,
-  deleteCollection,
-  createCategory,
-  updateCategory,
-  deleteCategory,
-  createAttribute,
-  updateAttribute,
-  deleteAttribute,
-  getCategoriesBaseQuery,
-  getCollectionsBaseQuery,
-  getProductsBaseQuery,
-  getProductsByCategoryBaseQuery,
-  getProductsByCollectionBaseQuery
-};
+  hookBeforeUpdateAttributeData,
+  hookAfterUpdateAttributeData,
+  hookBeforeUpdateAttributeGroups,
+  hookAfterUpdateAttributeGroups,
+  hookBeforeUpdateAttributeOptions,
+  hookAfterUpdateAttributeOptions,
+  hookBeforeUpdateAttribute,
+  hookAfterUpdateAttribute
+} from './attribute/updateProductAttribute.js';
+export { default as deleteAttribute } from './attribute/deleteProductAttribute.js';
+export * from './attribute/deleteProductAttribute.js';
+
+// Query helpers
+export * from './getCategoriesBaseQuery.js';
+export * from './getCollectionsBaseQuery.js';
+export * from './getProductsBaseQuery.js';
+export * from './getProductsByCategoryBaseQuery.js';
+export * from './getProductsByCollectionBaseQuery.js';