@evershop/evershop 2.1.1 → 2.1.2

package/src/modules/cms/services/widget/createWidget.ts

@@ -0,0 +1,120 @@
+import {
+  commit,
+  insert,
+  PoolClient,
+  rollback,
+  startTransaction
+} from '@evershop/postgres-query-builder';
+import { getConnection } from '../../../../lib/postgres/connection.js';
+import { hookable, hookBefore, hookAfter } from '../../../../lib/util/hookable.js';
+import {
+  getValue,
+  getValueSync
+} from '../../../../lib/util/registry.js';
+import { getAjv } from '../../../base/services/getAjv.js';
+import widgetDataSchema from './widgetDataSchema.json' with { type: 'json' };
+
+export type WidgetData = {
+  name: string;
+  status: number;
+  sort_order: number;
+  [key: string]: unknown;
+};
+
+function validateWidgetDataBeforeInsert(data: WidgetData): WidgetData {
+  const ajv = getAjv();
+  (widgetDataSchema as any).required = ['status', 'name', 'sort_order'];
+  const jsonSchema = getValueSync(
+    'createWidgetDataJsonSchema',
+    widgetDataSchema,
+    {}
+  );
+  const validate = ajv.compile(jsonSchema);
+  const valid = validate(data);
+  if (valid) {
+    return data;
+  } else {
+    throw new Error(validate.errors[0].message);
+  }
+}
+
+async function insertWidgetData(data: WidgetData, connection: PoolClient) {
+  const widget = await insert('widget').given(data).execute(connection);
+  return widget;
+}
+
+/**
+ * Create widget service. This service will create a widget with all related data
+ * @param {Object} data
+ * @param {Object} context
+ */
+async function createWidget(data: WidgetData, context: Record<string, any>) {
+  const connection = await getConnection();
+  await startTransaction(connection);
+  try {
+    const widgetData = await getValue('widgetDataBeforeCreate', data);
+    // Validate widget data
+    validateWidgetDataBeforeInsert(widgetData);
+
+    // Insert widget data
+    const widget = await hookable(insertWidgetData, { ...context, connection })(
+      widgetData,
+      connection
+    );
+
+    await commit(connection);
+    return widget;
+  } catch (e) {
+    await rollback(connection);
+    throw e;
+  }
+}
+
+export default async (data: WidgetData, context: Record<string, any>) => {
+  // 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');
+  }
+  const widget = await hookable(createWidget, context)(data, context);
+  return widget;
+};
+
+export function hookBeforeInsertWidgetData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: WidgetData, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('insertWidgetData', callback, priority);
+}
+
+export function hookAfterInsertWidgetData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: WidgetData, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('insertWidgetData', callback, priority);
+}
+
+export function hookBeforeCreateWidget(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: WidgetData, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('createWidget', callback, priority);
+}
+
+export function hookAfterCreateWidget(
+  callback: (
+    this: Record<string, any>,
+    ...args: [data: WidgetData, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('createWidget', callback, priority);
+}

package/src/modules/cms/services/widget/deleteWidget.ts

@@ -0,0 +1,97 @@
+import {
+  commit,
+  del,
+  PoolClient,
+  rollback,
+  select,
+  startTransaction
+} from '@evershop/postgres-query-builder';
+import { getConnection } from '../../../../lib/postgres/connection.js';
+import {
+  hookable,
+  hookBefore,
+  hookAfter
+} from '../../../../lib/util/hookable.js';
+import { WidgetData } from './createWidget.js';
+
+async function deleteWidgetData(uuid: string, connection: PoolClient) {
+  await del('widget').where('uuid', '=', uuid).execute(connection);
+}
+
+/**
+ * Delete widget service. This service will delete a widget with all related data
+ * @param {String} uuid
+ * @param {Object} context
+ */
+async function deleteWidget(uuid: string, context: Record<string, any>) {
+  const connection = await getConnection();
+  await startTransaction(connection);
+  try {
+    const query = select().from('widget');
+    const widget = await query.where('uuid', '=', uuid).load(connection);
+    if (!widget) {
+      throw new Error('Invalid widget id');
+    }
+    await hookable(deleteWidgetData, { ...context, widget, connection })(
+      uuid,
+      connection
+    );
+    await commit(connection);
+    return widget;
+  } catch (e) {
+    await rollback(connection);
+    throw e;
+  }
+}
+
+export default async (
+  uuid: string,
+  context: Record<string, any>
+): Promise<WidgetData> => {
+  // 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');
+  }
+  const widget = await hookable(deleteWidget, context)(uuid, context);
+  return widget;
+};
+
+export function hookBeforeDeleteWidgetData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteWidgetData', callback, priority);
+}
+
+export function hookAfterDeleteWidgetData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteWidgetData', callback, priority);
+}
+
+export function hookBeforeDeleteWidget(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteWidget', callback, priority);
+}
+
+export function hookAfterDeleteWidget(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteWidget', callback, priority);
+}

package/src/modules/cms/services/widget/updateWidget.js

@@ -6,7 +6,7 @@ import {
   update
 } 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 {
   getValue,
   getValueSync
@@ -82,3 +82,19 @@ export default async (uuid, data, context) => {
   const widget = await hookable(updateWidget, context)(uuid, data, context);
   return widget;
 };
+
+export function hookBeforeUpdateWidgetData(callback, priority = 10) {
+  hookBefore('updateWidgetData', callback, priority);
+}
+
+export function hookAfterUpdateWidgetData(callback, priority = 10) {
+  hookAfter('updateWidgetData', callback, priority);
+}
+
+export function hookBeforeUpdateWidget(callback, priority = 10) {
+  hookBefore('updateWidget', callback, priority);
+}
+
+export function hookAfterUpdateWidget(callback, priority = 10) {
+  hookAfter('updateWidget', callback, priority);
+}

package/src/modules/cms/services/widget/updateWidget.ts

@@ -0,0 +1,139 @@
+import {
+  commit,
+  PoolClient,
+  rollback,
+  select,
+  startTransaction,
+  update
+} from '@evershop/postgres-query-builder';
+import { getConnection } from '../../../../lib/postgres/connection.js';
+import { hookable, hookBefore, hookAfter } from '../../../../lib/util/hookable.js';
+import {
+  getValue,
+  getValueSync
+} from '../../../../lib/util/registry.js';
+import { getAjv } from '../../../base/services/getAjv.js';
+import { WidgetData } from './createWidget.js';
+import widgetDataSchema from './widgetDataSchema.json' with { type: 'json' };
+
+function validateWidgetDataBeforeInsert(data: Partial<WidgetData>): Partial<WidgetData> {
+  const ajv = getAjv();
+  (widgetDataSchema as any).required = ['status'];
+  const jsonSchema = getValueSync(
+    'updateWidgetDataJsonSchema',
+    widgetDataSchema,
+    {}
+  );
+  const validate = ajv.compile(jsonSchema);
+  const valid = validate(data);
+  if (valid) {
+    return data;
+  } else {
+    throw new Error(validate.errors[0].message);
+  }
+}
+
+async function updateWidgetData(
+  uuid: string,
+  data: Partial<WidgetData>,
+  connection: PoolClient
+) {
+  const query = select().from('widget');
+  const widget = await query.where('uuid', '=', uuid).load(connection);
+
+  if (!widget) {
+    throw new Error('Requested widget not found');
+  }
+  const newWidget = await update('widget')
+    .given(data)
+    .where('uuid', '=', uuid)
+    .execute(connection);
+
+  return newWidget;
+}
+
+/**
+ * Update widget service. This service will update a widget with all related data
+ * @param {String} uuid
+ * @param {Object} data
+ * @param {Object} context
+ */
+async function updateWidget(
+  uuid: string,
+  data: Partial<WidgetData>,
+  context: Record<string, any>
+) {
+  const connection = await getConnection();
+  await startTransaction(connection);
+  try {
+    const widgetData = await getValue('widgetDataBeforeUpdate', data);
+    // Validate widget data
+    validateWidgetDataBeforeInsert(widgetData);
+
+    // Update widget data
+    const widget = await hookable(updateWidgetData, { ...context, connection })(
+      uuid,
+      widgetData,
+      connection
+    );
+
+    await commit(connection);
+    return widget;
+  } catch (e) {
+    await rollback(connection);
+    throw e;
+  }
+}
+
+export default async (
+  uuid: string,
+  data: Partial<WidgetData>,
+  context: Record<string, any>
+) => {
+  // 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');
+  }
+  const widget = await hookable(updateWidget, context)(uuid, data, context);
+  return widget;
+};
+
+export function hookBeforeUpdateWidgetData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: Partial<WidgetData>, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateWidgetData', callback, priority);
+}
+
+export function hookAfterUpdateWidgetData(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: Partial<WidgetData>, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateWidgetData', callback, priority);
+}
+
+export function hookBeforeUpdateWidget(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: Partial<WidgetData>, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('updateWidget', callback, priority);
+}
+
+export function hookAfterUpdateWidget(
+  callback: (
+    this: Record<string, any>,
+    ...args: [uuid: string, data: Partial<WidgetData>, context: Record<string, any>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('updateWidget', callback, priority);
+}

package/src/modules/cod/pages/frontStore/checkout/CashOnDelivery.tsx

@@ -69,7 +69,9 @@ export default function CashOnDeliveryMethod({
           try {
             await checkout();
           } catch (error) {
-            toast.error(_('Failed to place order. Please try again.'));
+            toast.error(
+              error.message || _('Failed to place order. Please try again.')
+            );
           }
         };
 
@@ -143,7 +145,7 @@ export default function CashOnDeliveryMethod({
 }
 
 export const layout = {
-  areaId: 'checkoutForm',
+  areaId: 'checkoutFormAfter',
   sortOrder: 10
 };
 

package/src/modules/customer/api/refreshCustomerToken/refreshToken.ts

@@ -9,6 +9,7 @@ import {
   TOKEN_TYPES,
   verifyRefreshToken
 } from '../../../../lib/util/jwt.js';
+import { buildCustomerPayload } from '../../services/customer/buildCustomerPayload.js';
 
 export default async (request, response, next) => {
   const { refreshToken } = request.body;
@@ -41,16 +42,13 @@ export default async (request, response, next) => {
       });
     }
 
-    // Generate new access token
-    const payload = decoded.customer;
+    // Generate new access token using fresh customer data
+    const customerPayload = buildCustomerPayload(customer);
     const newAccessToken = generateToken(
-      {
-        customer: payload
-      },
+      { customer: customerPayload },
       TOKEN_TYPES.CUSTOMER
     );
     return response.json({
-      success: true,
       data: {
         accessToken: newAccessToken
       }

package/src/modules/customer/pages/frontStore/login/LoginPage.tsx

@@ -16,30 +16,32 @@ export default function LoginPage({
   forgotPasswordUrl
 }: LoginPageProps) {
   return (
-    <div className="login__page flex flex-col justify-center items-center">
-      <Card className="flex justify-center items-center max-w-max md:max-w-[80%]">
-        <CardContent>
-          <CustomerLoginForm
-            title={_('Welcome Back!')}
-            subtitle={_('Please sign in to your account')}
-            redirectUrl={homeUrl}
-            onError={(error) => {
-              toast.error(error.message);
-            }}
-            className="w-120"
-          />
-        </CardContent>
-      </Card>
-      <div className="login__page__options text-center mt-2 gap-5 flex justify-center">
-        <a className="text-interactive hover:underline" href={registerUrl}>
-          {_('Create an account')}
-        </a>
-        <a
-          className="text-destructive hover:underline"
-          href={forgotPasswordUrl}
-        >
-          {_('Forgot your password?')}
-        </a>
+    <div className="login__page flex flex-col items-center py-10 px-4">
+      <div className="w-full max-w-md">
+        <Card>
+          <CardContent>
+            <CustomerLoginForm
+              title={_('Welcome Back!')}
+              subtitle={_('Please sign in to your account')}
+              redirectUrl={homeUrl}
+              onError={(error) => {
+                toast.error(error.message);
+              }}
+              className="w-full"
+            />
+          </CardContent>
+        </Card>
+        <div className="login__page__options text-center mt-4 gap-5 flex justify-center">
+          <a className="text-interactive hover:underline" href={registerUrl}>
+            {_('Create an account')}
+          </a>
+          <a
+            className="text-destructive hover:underline"
+            href={forgotPasswordUrl}
+          >
+            {_('Forgot your password?')}
+          </a>
+        </div>
       </div>
     </div>
   );

package/src/modules/customer/pages/frontStore/register/RegisterPage.tsx

@@ -10,29 +10,31 @@ interface RegisterPageProps {
 }
 export default function RegisterPage({ homeUrl, loginUrl }: RegisterPageProps) {
   return (
-    <div className="flex justify-center items-center flex-col gap-3">
-      <Card className="flex justify-center items-center max-w-max md:max-w-[80%]">
-        <CardContent>
-          <CustomerRegistrationForm
-            title={_('Create an account')}
-            subtitle={_('Join us for exclusive offers and order tracking')}
-            redirectUrl={homeUrl}
-            onError={(error) => {
-              toast.error(error);
-            }}
-            className="w-120"
-          />
-        </CardContent>
-      </Card>
+    <div className="flex flex-col items-center py-10 px-4">
+      <div className="w-full max-w-md">
+        <Card>
+          <CardContent>
+            <CustomerRegistrationForm
+              title={_('Create an account')}
+              subtitle={_('Join us for exclusive offers and order tracking')}
+              redirectUrl={homeUrl}
+              onError={(error) => {
+                toast.error(error);
+              }}
+              className="w-full"
+            />
+          </CardContent>
+        </Card>
 
-      <div className="text-center">
-        <span>
-          {_('Already have an account?')}
-          <a className="text-primary hover:underline" href={loginUrl}>
-            {' '}
-            {_('Login')}{' '}
-          </a>
-        </span>
+        <div className="text-center mt-4">
+          <span>
+            {_('Already have an account?')}
+            <a className="text-primary hover:underline" href={loginUrl}>
+              {' '}
+              {_('Login')}{' '}
+            </a>
+          </span>
+        </div>
       </div>
     </div>
   );

package/src/modules/customer/services/customer/address/createCustomerAddress.ts

@@ -8,7 +8,11 @@ import {
   update
 } from '@evershop/postgres-query-builder';
 import { getConnection, pool } from '../../../../../lib/postgres/connection.js';
-import { hookable } from '../../../../../lib/util/hookable.js';
+import {
+  hookable,
+  hookBefore,
+  hookAfter
+} from '../../../../../lib/util/hookable.js';
 import { getValue } from '../../../../../lib/util/registry.js';
 import { Address } from '../../../../../types/customerAddress.js';
 import { validateAddress } from './addressValidators.js';
@@ -91,7 +95,7 @@ export default async (
   customerUUID: string,
   addressData: Address,
   context: Record<string, unknown>
-) => {
+): Promise<Address> => {
   // 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');
@@ -103,3 +107,51 @@ export default async (
   );
   return address;
 };
+
+export function hookBeforeInsertCustomerAddressData(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [data: Address, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('insertCustomerAddressData', callback, priority);
+}
+
+export function hookAfterInsertCustomerAddressData(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [data: Address, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('insertCustomerAddressData', callback, priority);
+}
+
+export function hookBeforeCreateCustomerAddress(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [
+      customerUUID: string,
+      address: Address,
+      context: Record<string, unknown>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('createCustomerAddress', callback, priority);
+}
+
+export function hookAfterCreateCustomerAddress(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [
+      customerUUID: string,
+      address: Address,
+      context: Record<string, unknown>
+    ]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('createCustomerAddress', callback, priority);
+}

package/src/modules/customer/services/customer/address/deleteCustomerAddress.ts

@@ -7,10 +7,17 @@ import {
   startTransaction
 } 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 { Address } from '../../../../../types/customerAddress.js';
 
-async function deleteCustomerAddressData(uuid: string, connection: PoolClient) {
+async function deleteCustomerAddressData(
+  uuid: string,
+  connection: PoolClient
+): Promise<void> {
   await del('customer_address').where('uuid', '=', uuid).execute(connection);
 }
 /**
@@ -68,3 +75,43 @@ export default async (
   );
   return customerAddress;
 };
+
+export function hookBeforeDeleteCustomerAddressData(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteCustomerAddressData', callback, priority);
+}
+
+export function hookAfterDeleteCustomerAddressData(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [uuid: string, connection: PoolClient]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteCustomerAddressData', callback, priority);
+}
+
+export function hookBeforeDeleteCustomerAddress(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [uuid: string, context: Record<string, unknown>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookBefore('deleteCustomerAddress', callback, priority);
+}
+
+export function hookAfterDeleteCustomerAddress(
+  callback: (
+    this: Record<string, unknown>,
+    ...args: [uuid: string, context: Record<string, unknown>]
+  ) => void | Promise<void>,
+  priority: number = 10
+): void {
+  hookAfter('deleteCustomerAddress', callback, priority);
+}