@unchainedshop/core 4.6.0 → 4.6.2

package/lib/services/removeCartItem.js

@@ -0,0 +1,19 @@
+import { updateCalculationService } from "./updateCalculation.js";
+import { OrderItemNotFoundError, OrderNotFoundError, OrderWrongStatusError } from "../errors/index.js";
+export async function removeCartItemService(params) {
+    const { itemId } = params;
+    const orderItem = await this.orders.positions.findOrderPosition({ itemId });
+    if (!orderItem) {
+        throw new OrderItemNotFoundError({ orderItemId: itemId });
+    }
+    const order = await this.orders.findOrder({ orderId: orderItem.orderId });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: orderItem.orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const removedOrderPosition = await this.orders.positions.delete(itemId);
+    await updateCalculationService.bind(this)(order._id);
+    return removedOrderPosition;
+}

package/lib/services/resetPasswordWithMigration.d.ts

@@ -0,0 +1,14 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface ResetPasswordParams {
+    token: string;
+    newPassword: string;
+}
+export interface HttpContext {
+    remoteAddress?: string;
+    remotePort?: number;
+    userAgent?: string;
+    locale?: string;
+    countryCode: string;
+}
+export declare function resetPasswordWithMigrationService(this: Modules, params: ResetPasswordParams, httpContext: HttpContext, currentUserId?: string): Promise<User>;

package/lib/services/resetPasswordWithMigration.js

@@ -0,0 +1,31 @@
+import { migrateUserDataService } from "./migrateUserData.js";
+import { nextUserCartService } from "./nextUserCart.js";
+import { InvalidResetTokenError, PasswordInvalidError } from "../errors/index.js";
+export async function resetPasswordWithMigrationService(params, httpContext, currentUserId) {
+    const { token, newPassword } = params;
+    let user;
+    try {
+        user = await this.users.resetPassword(token, newPassword);
+    }
+    catch (e) {
+        if (e && typeof e === 'object' && 'cause' in e && e.cause === 'PASSWORD_INVALID') {
+            throw new PasswordInvalidError();
+        }
+        throw e;
+    }
+    if (!user) {
+        throw new InvalidResetTokenError();
+    }
+    user = (await this.users.updateHeartbeat(user._id, {
+        remoteAddress: httpContext.remoteAddress,
+        remotePort: httpContext.remotePort,
+        userAgent: httpContext.userAgent,
+        locale: httpContext.locale,
+        countryCode: httpContext.countryCode,
+    }));
+    if (currentUserId) {
+        await migrateUserDataService.bind(this)(currentUserId, user._id);
+    }
+    await nextUserCartService.bind(this)({ user, countryCode: httpContext.countryCode });
+    return user;
+}

package/lib/services/resolveWorkType.d.ts

@@ -0,0 +1 @@
+export declare function resolveWorkTypeService(workType: string): string;

package/lib/services/resolveWorkType.js

@@ -0,0 +1,7 @@
+import { WorkerDirector } from "../directors/WorkerDirector.js";
+export function resolveWorkTypeService(workType) {
+    if (WorkerDirector.getActivePluginTypes().includes(workType)) {
+        return workType;
+    }
+    return 'UNKNOWN';
+}

package/lib/services/searchProductsWithAssortment.d.ts

@@ -0,0 +1,19 @@
+import type { Assortment } from '@unchainedshop/core-assortments';
+import type { SearchQuery } from '@unchainedshop/core-filters';
+import type { Modules } from '../modules.ts';
+export interface SearchProductsWithAssortmentParams extends SearchQuery {
+    assortmentId?: string;
+    assortment?: Assortment;
+    ignoreChildAssortments?: boolean;
+}
+export interface SearchProductsOptions {
+    locale: Intl.Locale;
+    userId?: string;
+    forceLiveCollection?: boolean;
+}
+export declare function searchProductsWithAssortmentService(this: Modules, params: SearchProductsWithAssortmentParams, options: SearchProductsOptions): Promise<{
+    searchConfiguration: import("../core-index.ts").SearchProductsOptions;
+    totalProductIds: string[];
+    aggregatedTotalProductIds: string[];
+    aggregatedFilteredProductIds: string[];
+}>;

package/lib/services/searchProductsWithAssortment.js

@@ -0,0 +1,17 @@
+import { searchProductsService } from "./searchProducts.js";
+export async function searchProductsWithAssortmentService(params, options) {
+    const { assortmentId, assortment: providedAssortment, ignoreChildAssortments, ...searchQuery } = params;
+    const assortment = providedAssortment ||
+        (assortmentId ? await this.assortments.findAssortment({ assortmentId }) : null);
+    if (!assortment) {
+        return searchProductsService.call(this, searchQuery, options);
+    }
+    const [productIds, filterIds] = await Promise.all([
+        this.assortments.findProductIds({
+            assortment,
+            ignoreChildAssortments: ignoreChildAssortments || false,
+        }),
+        this.assortments.filters.findFilterIds({ assortmentId: assortment._id }),
+    ]);
+    return searchProductsService.call(this, { ...searchQuery, productIds, filterIds }, options);
+}

package/lib/services/toggleBookmark.d.ts

@@ -0,0 +1,8 @@
+import type { Bookmark } from '@unchainedshop/core-bookmarks';
+import type { Modules } from '../modules.ts';
+export interface ToggleBookmarkParams {
+    productId: string;
+    userId: string;
+    bookmarked: boolean;
+}
+export declare function toggleBookmarkService(this: Modules, params: ToggleBookmarkParams): Promise<Bookmark>;

package/lib/services/toggleBookmark.js

@@ -0,0 +1,33 @@
+import { ProductNotFoundError, BookmarkNotFoundError, MultipleBookmarksFoundError, } from "../errors/index.js";
+export async function toggleBookmarkService(params) {
+    const { productId, userId, bookmarked } = params;
+    if (!(await this.products.productExists({ productId }))) {
+        throw new ProductNotFoundError({ productId });
+    }
+    const foundBookmarks = await this.bookmarks.findBookmarks({
+        productId,
+        userId,
+    });
+    if (foundBookmarks.length > 1) {
+        throw new MultipleBookmarksFoundError({
+            productId,
+            userId,
+            bookmarkIds: foundBookmarks.map((b) => b._id),
+        });
+    }
+    const foundBookmark = foundBookmarks[0];
+    if (bookmarked) {
+        if (foundBookmark)
+            return foundBookmark;
+        const bookmarkId = await this.bookmarks.create({
+            productId,
+            userId,
+        });
+        return (await this.bookmarks.findBookmarkById(bookmarkId));
+    }
+    if (!foundBookmark) {
+        throw new BookmarkNotFoundError({ productId, userId });
+    }
+    await this.bookmarks.delete(foundBookmark._id);
+    return foundBookmark;
+}

package/lib/services/updateCart.d.ts

@@ -0,0 +1,15 @@
+import type { Order } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Address, Contact } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface UpdateCartParams {
+    orderId?: string;
+    billingAddress?: Address;
+    contact?: Contact;
+    paymentProviderId?: string;
+    deliveryProviderId?: string;
+    meta?: any;
+    user: User;
+    countryCode: string;
+}
+export declare function updateCartService(this: Modules, params: UpdateCartParams): Promise<Order>;

package/lib/services/updateCart.js

@@ -0,0 +1,27 @@
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { OrderNotFoundError, OrderWrongStatusError } from "../errors/index.js";
+export async function updateCartService(params) {
+    const { orderId, billingAddress, contact, paymentProviderId, deliveryProviderId, meta, user, countryCode, } = params;
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    if (meta || billingAddress || contact) {
+        await this.orders.updateCartFields(order._id, { meta, billingAddress, contact });
+    }
+    if (paymentProviderId) {
+        await this.orders.setPaymentProvider(order._id, paymentProviderId);
+    }
+    if (deliveryProviderId) {
+        await this.orders.setDeliveryProvider(order._id, deliveryProviderId);
+    }
+    return updateCalculationService.bind(this)(order._id);
+}

package/lib/services/updateCartItem.d.ts

@@ -0,0 +1,11 @@
+import { type OrderPosition } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export interface UpdateCartItemParams {
+    itemId: string;
+    quantity?: number;
+    configuration?: {
+        key: string;
+        value: string;
+    }[];
+}
+export declare function updateCartItemService(this: Modules, params: UpdateCartItemParams, context: any): Promise<OrderPosition>;

package/lib/services/updateCartItem.js

@@ -0,0 +1,37 @@
+import { ordersSettings } from '@unchainedshop/core-orders';
+import { updateCalculationService } from "./updateCalculation.js";
+import { OrderItemNotFoundError, OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, } from "../errors/index.js";
+export async function updateCartItemService(params, context) {
+    const { itemId, configuration, quantity = 1 } = params;
+    const item = await this.orders.positions.findOrderPosition({ itemId });
+    if (!item) {
+        throw new OrderItemNotFoundError({ orderItemId: itemId });
+    }
+    const order = await this.orders.findOrder({ orderId: item.orderId });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: item.orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const product = await this.products.findProduct({ productId: item.productId });
+    if (!product) {
+        throw new ProductNotFoundError({ productId: item.productId });
+    }
+    if (quantity !== null && quantity < 1) {
+        throw new OrderQuantityTooLowError({ quantity });
+    }
+    await ordersSettings.validateOrderPosition({
+        order,
+        product,
+        configuration,
+        quantityDiff: quantity - item.quantity,
+    }, context);
+    await this.orders.positions.updateProductItem({
+        orderPositionId: item._id,
+        quantity: quantity || null,
+        configuration: configuration || null,
+    });
+    await updateCalculationService.bind(this)(order._id);
+    return (await this.orders.positions.findOrderPosition({ itemId: item._id }));
+}

package/lib/services/updateEnrollment.d.ts

@@ -0,0 +1,13 @@
+import { type Enrollment, type EnrollmentPlan } from '@unchainedshop/core-enrollments';
+import type { Address, Contact } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface UpdateEnrollmentParams {
+    enrollmentId: string;
+    contact?: Contact;
+    plan?: EnrollmentPlan;
+    billingAddress?: Address;
+    payment?: Enrollment['payment'];
+    delivery?: Enrollment['delivery'];
+    meta?: any;
+}
+export declare function updateEnrollmentService(this: Modules, params: UpdateEnrollmentParams): Promise<Enrollment>;

package/lib/services/updateEnrollment.js

@@ -0,0 +1,36 @@
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { initializeEnrollmentService } from "./initializeEnrollment.js";
+import { EnrollmentNotFoundError, EnrollmentWrongStatusError, EnrollmentPlanUpdateNotAllowedError, } from "../errors/index.js";
+export async function updateEnrollmentService(params) {
+    const { enrollmentId, billingAddress, contact, delivery, meta, payment, plan } = params;
+    let enrollment = await this.enrollments.findEnrollment({ enrollmentId });
+    if (!enrollment) {
+        throw new EnrollmentNotFoundError({ enrollmentId });
+    }
+    if (enrollment.status === EnrollmentStatus.TERMINATED) {
+        throw new EnrollmentWrongStatusError({ status: enrollment.status, enrollmentId: enrollment._id });
+    }
+    if (meta) {
+        enrollment = (await this.enrollments.updateContext(enrollmentId, meta));
+    }
+    if (billingAddress) {
+        enrollment = (await this.enrollments.updateBillingAddress(enrollmentId, billingAddress));
+    }
+    if (contact) {
+        enrollment = (await this.enrollments.updateContact(enrollmentId, contact));
+    }
+    if (payment) {
+        enrollment = (await this.enrollments.updatePayment(enrollmentId, payment));
+    }
+    if (delivery) {
+        enrollment = (await this.enrollments.updateDelivery(enrollmentId, delivery));
+    }
+    if (plan) {
+        if (enrollment.status !== EnrollmentStatus.INITIAL) {
+            throw new EnrollmentPlanUpdateNotAllowedError({ status: enrollment.status, enrollmentId });
+        }
+        enrollment = (await this.enrollments.updatePlan(enrollmentId, plan));
+        enrollment = await initializeEnrollmentService.bind(this)(enrollment, { reason: 'updated_plan' });
+    }
+    return enrollment;
+}

package/lib/services/verifyEmailWithMigration.d.ts

@@ -0,0 +1,15 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface VerifyEmailHttpContext {
+    remoteAddress?: string;
+    remotePort?: number;
+    userAgent?: string;
+    locale?: string;
+    countryCode: string;
+}
+export interface VerifyEmailParams {
+    token: string;
+    currentUserId?: string;
+    httpContext: VerifyEmailHttpContext;
+}
+export declare function verifyEmailWithMigrationService(this: Modules, params: VerifyEmailParams): Promise<User>;

package/lib/services/verifyEmailWithMigration.js

@@ -0,0 +1,23 @@
+import { nextUserCartService } from "./nextUserCart.js";
+import { migrateUserDataService } from "./migrateUserData.js";
+import { InvalidEmailVerificationTokenError } from "../errors/index.js";
+export async function verifyEmailWithMigrationService(params) {
+    const { token, currentUserId, httpContext } = params;
+    const unverifiedToken = await this.users.findUnverifiedEmailToken(token);
+    if (!unverifiedToken) {
+        throw new InvalidEmailVerificationTokenError({ token });
+    }
+    await this.users.verifyEmail(unverifiedToken.userId, unverifiedToken.address);
+    const user = (await this.users.updateHeartbeat(unverifiedToken.userId, {
+        remoteAddress: httpContext.remoteAddress,
+        remotePort: httpContext.remotePort,
+        userAgent: httpContext.userAgent,
+        locale: httpContext.locale,
+        countryCode: httpContext.countryCode,
+    }));
+    if (currentUserId) {
+        await migrateUserDataService.bind(this)(currentUserId, user._id);
+    }
+    await nextUserCartService.bind(this)({ user, countryCode: httpContext.countryCode });
+    return user;
+}

package/lib/utils/getFileAdapter.d.ts

@@ -0,0 +1 @@
+export declare const getFileAdapter: () => import("@unchainedshop/core-files").IFileAdapter<unknown>;

package/lib/utils/getFileAdapter.js

@@ -0,0 +1,7 @@
+import { FileDirector } from "../directors/FileDirector.js";
+export const getFileAdapter = () => {
+    const adapters = FileDirector.getAdapters();
+    if (adapters.length === 0)
+        throw Error('No file adapter found.');
+    return adapters[0];
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core",
   "description": "Core orchestration package for the Unchained Engine with business services and directors",
-  "version": "4.6.0",
+  "version": "4.6.2",
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",