@unchainedshop/core 4.8.26 → 4.8.27

package/lib/services/registerUser.d.ts

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

package/lib/services/registerUser.js

@@ -0,0 +1,44 @@
+import { nextUserCartService } from "./nextUserCart.js";
+import { UsernameOrEmailRequiredError, PasswordOrWebAuthnPublicKeyRequiredError, EmailAlreadyExistsError, UsernameAlreadyExistsError, PasswordInvalidError, WebAuthnVerificationFailedError, AuthOperationFailedError, } from "../errors/index.js";
+export async function registerUserService(params, httpContext) {
+    if (!params.username && !params.email) {
+        throw new UsernameOrEmailRequiredError();
+    }
+    if (!params.password && !params.webAuthnPublicKeyCredentials) {
+        throw new PasswordOrWebAuthnPublicKeyRequiredError({ username: params.username });
+    }
+    const usersCountBeforeCreation = await this.users.count({
+        includeDeleted: true,
+        includeGuests: true,
+    });
+    const isFirstUser = usersCountBeforeCreation === 0;
+    let newUserId;
+    try {
+        newUserId = await this.users.createUser({
+            ...params,
+            initialPassword: false,
+            roles: isFirstUser ? ['admin'] : [],
+        }, {});
+    }
+    catch (e) {
+        if (e.cause === 'EMAIL_INVALID')
+            throw new EmailAlreadyExistsError({ email: params.email });
+        else if (e.cause === 'USERNAME_INVALID')
+            throw new UsernameAlreadyExistsError({ username: params.username });
+        else if (e.cause === 'PASSWORD_INVALID')
+            throw new PasswordInvalidError({ username: params.username });
+        else if (e.cause === 'WEBAUTHN_INVALID')
+            throw new WebAuthnVerificationFailedError({ username: params.username });
+        else
+            throw new AuthOperationFailedError({ username: params.username, email: params.email });
+    }
+    const user = (await this.users.updateHeartbeat(newUserId, {
+        remoteAddress: httpContext.remoteAddress,
+        remotePort: httpContext.remotePort,
+        userAgent: httpContext.userAgent,
+        locale: httpContext.locale,
+        countryCode: httpContext.countryCode,
+    }));
+    await nextUserCartService.bind(this)({ user, countryCode: httpContext.countryCode });
+    return { user, isFirstUser };
+}

package/lib/services/removeBookmark.d.ts

@@ -0,0 +1,6 @@
+import type { Bookmark } from '@unchainedshop/core-bookmarks';
+import type { Modules } from '../modules.ts';
+export interface RemoveBookmarkParams {
+    bookmarkId: string;
+}
+export declare function removeBookmarkService(this: Modules, params: RemoveBookmarkParams): Promise<Bookmark>;

package/lib/services/removeBookmark.js

@@ -0,0 +1,10 @@
+import { BookmarkNotFoundError } from "../errors/index.js";
+export async function removeBookmarkService(params) {
+    const { bookmarkId } = params;
+    const bookmark = await this.bookmarks.findBookmarkById(bookmarkId);
+    if (!bookmark) {
+        throw new BookmarkNotFoundError({ bookmarkId });
+    }
+    await this.bookmarks.delete(bookmarkId);
+    return bookmark;
+}

package/lib/services/removeCartItem.d.ts

@@ -0,0 +1,6 @@
+import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export interface RemoveCartItemParams {
+    itemId: string;
+}
+export declare function removeCartItemService(this: Modules, params: RemoveCartItemParams): Promise<OrderPosition>;

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.8.26",
+  "version": "4.8.27",
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",
@@ -35,28 +35,28 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/core-assortments": "^4.8.12",
-    "@unchainedshop/core-bookmarks": "^4.8.12",
-    "@unchainedshop/core-countries": "^4.8.12",
-    "@unchainedshop/core-currencies": "^4.8.12",
-    "@unchainedshop/core-delivery": "^4.8.12",
-    "@unchainedshop/core-enrollments": "^4.8.12",
-    "@unchainedshop/core-events": "^4.8.12",
-    "@unchainedshop/core-files": "^4.8.12",
-    "@unchainedshop/core-filters": "^4.8.12",
-    "@unchainedshop/core-languages": "^4.8.12",
-    "@unchainedshop/core-orders": "^4.8.12",
-    "@unchainedshop/core-payment": "^4.8.12",
-    "@unchainedshop/core-products": "^4.8.12",
-    "@unchainedshop/core-quotations": "^4.8.12",
-    "@unchainedshop/core-users": "^4.8.12",
-    "@unchainedshop/core-warehousing": "^4.8.12",
-    "@unchainedshop/core-worker": "^4.8.12",
-    "@unchainedshop/events": "^4.8.12",
-    "@unchainedshop/file-upload": "^4.8.12",
-    "@unchainedshop/logger": "^4.8.12",
-    "@unchainedshop/mongodb": "^4.8.12",
-    "@unchainedshop/utils": "^4.8.12",
+    "@unchainedshop/core-assortments": "^4.8.27",
+    "@unchainedshop/core-bookmarks": "^4.8.27",
+    "@unchainedshop/core-countries": "^4.8.27",
+    "@unchainedshop/core-currencies": "^4.8.27",
+    "@unchainedshop/core-delivery": "^4.8.27",
+    "@unchainedshop/core-enrollments": "^4.8.27",
+    "@unchainedshop/core-events": "^4.8.27",
+    "@unchainedshop/core-files": "^4.8.27",
+    "@unchainedshop/core-filters": "^4.8.27",
+    "@unchainedshop/core-languages": "^4.8.27",
+    "@unchainedshop/core-orders": "^4.8.27",
+    "@unchainedshop/core-payment": "^4.8.27",
+    "@unchainedshop/core-products": "^4.8.27",
+    "@unchainedshop/core-quotations": "^4.8.27",
+    "@unchainedshop/core-users": "^4.8.27",
+    "@unchainedshop/core-warehousing": "^4.8.27",
+    "@unchainedshop/core-worker": "^4.8.27",
+    "@unchainedshop/events": "^4.8.27",
+    "@unchainedshop/file-upload": "^4.8.27",
+    "@unchainedshop/logger": "^4.8.27",
+    "@unchainedshop/mongodb": "^4.8.27",
+    "@unchainedshop/utils": "^4.8.27",
     "minipass-json-stream": "^1.0.2",
     "zod": "^4.2.0"
   },