@unchainedshop/core 4.8.29 → 4.8.30

package/lib/errors/index.d.ts

@@ -1 +0,0 @@
-export * from './common.ts';

package/lib/errors/index.js

@@ -1 +0,0 @@
-export * from "./common.js";

package/lib/services/addCartDiscount.d.ts

@@ -1,10 +0,0 @@
-import type { OrderDiscount } from '@unchainedshop/core-orders';
-import type { Modules } from '../modules.ts';
-import type { User } from '@unchainedshop/core-users';
-export interface AddCartDiscountParams {
-    orderId?: string;
-    code: string;
-    user: User;
-    countryCode: string;
-}
-export declare function addCartDiscountService(this: Modules, params: AddCartDiscountParams): Promise<OrderDiscount>;

package/lib/services/addCartDiscount.js

@@ -1,27 +0,0 @@
-import { createManualOrderDiscountService } from "./createManualOrderDiscount.js";
-import { updateCalculationService } from "./updateCalculation.js";
-import { findOrInitCartService } from "./findOrInitCart.js";
-import { OrderNotFoundError, OrderWrongStatusError, OrderDiscountCodeAlreadyPresentError, OrderDiscountCodeNotValidError, } from "../errors/index.js";
-export async function addCartDiscountService(params) {
-    const { orderId, code, user, countryCode } = params;
-    const order = await findOrInitCartService.bind(this)({
-        orderId,
-        user,
-        countryCode,
-    });
-    if (!order) {
-        throw new OrderNotFoundError({ orderId: orderId || null });
-    }
-    if (!this.orders.isCart(order)) {
-        throw new OrderWrongStatusError({ status: order.status });
-    }
-    if (await this.orders.discounts.isDiscountCodeUsed({ code, orderId: order._id })) {
-        throw new OrderDiscountCodeAlreadyPresentError({ orderId: order._id, code });
-    }
-    const discount = await createManualOrderDiscountService.bind(this)({ order, code });
-    if (!discount) {
-        throw new OrderDiscountCodeNotValidError({ code });
-    }
-    await updateCalculationService.bind(this)(order._id);
-    return discount;
-}

package/lib/services/addCartItem.d.ts

@@ -1,15 +0,0 @@
-import { type OrderPosition } from '@unchainedshop/core-orders';
-import type { User } from '@unchainedshop/core-users';
-import type { Modules } from '../modules.ts';
-export interface AddCartItemParams {
-    orderId?: string;
-    productId: string;
-    quantity: number;
-    configuration?: {
-        key: string;
-        value: string;
-    }[];
-    user: User;
-    countryCode: string;
-}
-export declare function addCartItemService(this: Modules, params: AddCartItemParams, context: any): Promise<OrderPosition>;

package/lib/services/addCartItem.js

@@ -1,41 +0,0 @@
-import { ordersSettings } from '@unchainedshop/core-orders';
-import { findOrInitCartService } from "./findOrInitCart.js";
-import { updateCalculationService } from "./updateCalculation.js";
-import { ProductNotFoundError, OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, } from "../errors/index.js";
-export async function addCartItemService(params, context) {
-    const { orderId, productId: originalProductId, quantity, configuration, user, countryCode } = params;
-    if (quantity < 1) {
-        throw new OrderQuantityTooLowError({ quantity });
-    }
-    const originalProduct = await this.products.findProduct({ productId: originalProductId });
-    if (!originalProduct) {
-        throw new ProductNotFoundError({ productId: originalProductId });
-    }
-    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 });
-    }
-    const product = await this.products.resolveOrderableProduct(originalProduct, { configuration });
-    await ordersSettings.validateOrderPosition({
-        order,
-        product,
-        configuration,
-        quantityDiff: quantity,
-    }, context);
-    const orderPosition = await this.orders.positions.addProductItem({
-        quantity,
-        configuration,
-        productId: product._id,
-        originalProductId,
-        orderId: order._id,
-    });
-    await updateCalculationService.bind(this)(order._id);
-    return (await this.orders.positions.findOrderPosition({ itemId: orderPosition._id }));
-}

package/lib/services/addEmail.d.ts

@@ -1,7 +0,0 @@
-import type { User } from '@unchainedshop/core-users';
-import type { Modules } from '../modules.ts';
-export interface AddEmailParams {
-    userId: string;
-    email: string;
-}
-export declare function addEmailService(this: Modules, params: AddEmailParams): Promise<User>;

package/lib/services/addEmail.js

@@ -1,17 +0,0 @@
-import { UserNotFoundError, EmailAlreadyExistsError } from "../errors/index.js";
-export async function addEmailService(params) {
-    const { userId, email } = params;
-    if (!(await this.users.userExists({ userId }))) {
-        throw new UserNotFoundError({ userId });
-    }
-    try {
-        await this.users.addEmail(userId, email);
-    }
-    catch (e) {
-        if (e.cause === 'EMAIL_INVALID') {
-            throw new EmailAlreadyExistsError({ email });
-        }
-        throw e;
-    }
-    return (await this.users.findUserById(userId));
-}

package/lib/services/addProductAssignment.d.ts

@@ -1,3 +0,0 @@
-import { type Product, type ProductConfiguration } from '@unchainedshop/core-products';
-import type { Modules } from '../modules.ts';
-export declare function addProductAssignmentService(this: Modules, proxyId: string, productId: string, vectors: ProductConfiguration[]): Promise<Product | null>;

package/lib/services/addProductAssignment.js

@@ -1,63 +0,0 @@
-import { ProductType, } from '@unchainedshop/core-products';
-import { ProductNotFoundError, ProductWrongTypeError, ProductVariationInfinityLoopError, ProductVariationVectorInvalidError, ProductVariationVectorAlreadySetError, } from "../errors/index.js";
-const extractVariationMatrix = (variations = []) => {
-    const cartesianProduct = (arrays) => {
-        return arrays.reduce((acc, array) => acc.flatMap((item) => array.map((value) => [...item, value])), [
-            [],
-        ]);
-    };
-    const keys = variations.map((item) => item.key);
-    const options = variations.map((item) => item.options);
-    const combinations = cartesianProduct(options);
-    return combinations.map((combination) => combination.reduce((acc, value, index) => {
-        acc[keys[index]] = value;
-        return acc;
-    }, {}));
-};
-const combinationExists = (matrix, combination) => {
-    return matrix.some((variation) => {
-        return (Object.keys(variation).length === Object.keys(combination).length &&
-            Object.entries(combination).every(([key, value]) => variation[key] === value));
-    });
-};
-export async function addProductAssignmentService(proxyId, productId, vectors) {
-    if (!(await this.products.productExists({ productId }))) {
-        throw new ProductNotFoundError({ productId });
-    }
-    const proxyProduct = await this.products.findProduct({ productId: proxyId });
-    if (!proxyProduct) {
-        throw new ProductNotFoundError({ productId: proxyId });
-    }
-    if (productId === proxyId) {
-        throw new ProductVariationInfinityLoopError({ productId });
-    }
-    if (proxyProduct.type !== ProductType.CONFIGURABLE_PRODUCT) {
-        throw new ProductWrongTypeError({
-            proxyId,
-            received: proxyProduct.type,
-            required: ProductType.CONFIGURABLE_PRODUCT,
-        });
-    }
-    const variations = await this.products.variations.findProductVariations({
-        productId: proxyId,
-    });
-    const variationMatrix = extractVariationMatrix(variations);
-    const normalizedVectors = vectors?.reduce((prev, { key, value }) => {
-        return {
-            ...prev,
-            [key]: value,
-        };
-    }, {});
-    if (!combinationExists(variationMatrix, normalizedVectors)) {
-        throw new ProductVariationVectorInvalidError({ proxyId, vectors });
-    }
-    const added = await this.products.assignments.addProxyAssignment({
-        productId,
-        proxyId,
-        vectors,
-    });
-    if (!added) {
-        throw new ProductVariationVectorAlreadySetError({ proxyId, vectors });
-    }
-    return this.products.findProduct({ productId: proxyId });
-}

package/lib/services/authenticateWithPassword.d.ts

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

package/lib/services/authenticateWithPassword.js

@@ -1,34 +0,0 @@
-import { migrateUserDataService } from "./migrateUserData.js";
-import { nextUserCartService } from "./nextUserCart.js";
-import { UsernameOrEmailRequiredError, InvalidCredentialsError } from "../errors/index.js";
-export async function authenticateWithPasswordService(params, httpContext, currentUserId) {
-    const { username, email, password } = params;
-    if (!username && !email) {
-        throw new UsernameOrEmailRequiredError();
-    }
-    let user = username
-        ? await this.users.findUserByUsername(username)
-        : await this.users.findUserByEmail(email);
-    if (!user) {
-        throw new InvalidCredentialsError({ username, email });
-    }
-    const verified = user.services?.password && (await this.users.verifyPassword(user.services.password, password));
-    if (!verified) {
-        throw new InvalidCredentialsError({ username, email });
-    }
-    if (user.guest) {
-        await this.users.updateGuest(user, false);
-    }
-    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/changePassword.d.ts

@@ -1,10 +0,0 @@
-import type { Modules } from '../modules.ts';
-export interface ChangePasswordParams {
-    userId: string;
-    oldPassword: string;
-    newPassword: string;
-}
-export interface ChangePasswordResult {
-    success: boolean;
-}
-export declare function changePasswordService(this: Modules, params: ChangePasswordParams): Promise<ChangePasswordResult>;

package/lib/services/changePassword.js

@@ -1,19 +0,0 @@
-import { InvalidCredentialsError, PasswordInvalidError } from "../errors/index.js";
-export async function changePasswordService(params) {
-    const { userId, oldPassword, newPassword } = params;
-    const user = await this.users.findUserById(userId);
-    const isValidCurrentPassword = user?.services?.password && (await this.users.verifyPassword(user.services.password, oldPassword));
-    if (!isValidCurrentPassword) {
-        throw new InvalidCredentialsError();
-    }
-    try {
-        await this.users.setPassword(user._id, newPassword);
-        return { success: true };
-    }
-    catch (e) {
-        if (e.cause === 'PASSWORD_INVALID') {
-            throw new PasswordInvalidError({ userId });
-        }
-        throw e;
-    }
-}

package/lib/services/countOrdersWithFilters.d.ts

@@ -1,3 +0,0 @@
-import type { OrderQuery } from '@unchainedshop/core-orders';
-import type { Modules } from '../modules.ts';
-export declare function countOrdersWithFiltersService(this: Modules, params: OrderQuery): Promise<number>;

package/lib/services/countOrdersWithFilters.js

@@ -1,25 +0,0 @@
-export async function countOrdersWithFiltersService(params) {
-    const { paymentProviderIds, deliveryProviderIds, ...restParams } = params;
-    if (!paymentProviderIds?.length && !deliveryProviderIds?.length) {
-        return this.orders.count(restParams);
-    }
-    const [orderPayments, orderDeliveries] = await Promise.all([
-        paymentProviderIds?.length
-            ? this.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
-            : [],
-        deliveryProviderIds?.length
-            ? this.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
-            : [],
-    ]);
-    if ((paymentProviderIds?.length && !orderPayments.length) ||
-        (deliveryProviderIds?.length && !orderDeliveries.length)) {
-        return 0;
-    }
-    const paymentIds = orderPayments.map((p) => p._id);
-    const deliveryIds = orderDeliveries.map((d) => d._id);
-    return this.orders.count({
-        ...restParams,
-        paymentIds,
-        deliveryIds,
-    });
-}

package/lib/services/createAssortment.d.ts

@@ -1,7 +0,0 @@
-import type { Assortment, AssortmentText } from '@unchainedshop/core-assortments';
-import type { Modules } from '../modules.ts';
-export interface CreateAssortmentParams {
-    assortment: Partial<Assortment>;
-    texts?: AssortmentText[];
-}
-export declare function createAssortmentService(this: Modules, params: CreateAssortmentParams): Promise<Assortment>;

package/lib/services/createAssortment.js

@@ -1,10 +0,0 @@
-export async function createAssortmentService(params) {
-    const { assortment: assortmentData, texts } = params;
-    const assortment = await this.assortments.create({
-        ...assortmentData,
-    });
-    if (texts) {
-        await this.assortments.texts.updateTexts(assortment._id, texts);
-    }
-    return assortment;
-}

package/lib/services/createBookmark.d.ts

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

package/lib/services/createBookmark.js

@@ -1,21 +0,0 @@
-import { ProductNotFoundError, BookmarkAlreadyExistsError } from "../errors/index.js";
-export async function createBookmarkService(params) {
-    const { productId, userId, meta } = params;
-    if (!(await this.products.productExists({ productId }))) {
-        throw new ProductNotFoundError({ productId });
-    }
-    const [existingBookmark] = await this.bookmarks.findBookmarks({
-        productId,
-        userId,
-        meta,
-    });
-    if (existingBookmark) {
-        throw new BookmarkAlreadyExistsError({ bookmarkId: existingBookmark._id });
-    }
-    const bookmarkId = await this.bookmarks.create({
-        userId,
-        productId,
-        meta,
-    });
-    return (await this.bookmarks.findBookmarkById(bookmarkId));
-}

package/lib/services/createDeliveryProvider.d.ts

@@ -1,6 +0,0 @@
-import type { DeliveryProvider } from '@unchainedshop/core-delivery';
-import type { Modules } from '../modules.ts';
-export interface CreateDeliveryProviderParams {
-    deliveryProvider: Pick<DeliveryProvider, 'type' | 'adapterKey'>;
-}
-export declare function createDeliveryProviderService(this: Modules, params: CreateDeliveryProviderParams): Promise<DeliveryProvider | null>;

package/lib/services/createDeliveryProvider.js

@@ -1,19 +0,0 @@
-import { DeliveryDirector } from "../directors/DeliveryDirector.js";
-import { ProviderConfigurationInvalidError } from "../errors/index.js";
-export async function createDeliveryProviderService(params) {
-    const { deliveryProvider } = params;
-    const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
-    if (!Adapter)
-        return null;
-    const provider = await this.delivery.create({
-        configuration: Adapter.initialConfiguration,
-        ...deliveryProvider,
-    });
-    if (!provider) {
-        throw new ProviderConfigurationInvalidError({
-            adapterKey: deliveryProvider.adapterKey,
-            type: deliveryProvider.type,
-        });
-    }
-    return provider;
-}

package/lib/services/createEnrollment.d.ts

@@ -1,17 +0,0 @@
-import type { Enrollment, EnrollmentPlan } from '@unchainedshop/core-enrollments';
-import type { Address, Contact } from '@unchainedshop/core-users';
-import type { Modules } from '../modules.ts';
-export interface CreateEnrollmentParams {
-    productId: string;
-    quantity?: number;
-    configuration?: EnrollmentPlan['configuration'];
-    billingAddress?: Address;
-    contact?: Contact;
-    payment?: Enrollment['payment'];
-    delivery?: Enrollment['delivery'];
-    meta?: any;
-    countryCode: string;
-    currencyCode: string;
-    userId: string;
-}
-export declare function createEnrollmentService(this: Modules, params: CreateEnrollmentParams): Promise<Enrollment>;

package/lib/services/createEnrollment.js

@@ -1,33 +0,0 @@
-import { ProductStatus, ProductType } from '@unchainedshop/core-products';
-import { initializeEnrollmentService } from "./initializeEnrollment.js";
-import { ProductNotFoundError, ProductWrongStatusError, ProductWrongTypeError, } from "../errors/index.js";
-export async function createEnrollmentService(params) {
-    const { productId, quantity, configuration, billingAddress, contact, payment, delivery, meta, countryCode, currencyCode, userId, } = params;
-    const product = await this.products.findProduct({ productId });
-    if (!product) {
-        throw new ProductNotFoundError({ productId });
-    }
-    if (product.status !== ProductStatus.ACTIVE) {
-        throw new ProductWrongStatusError({ status: product.status });
-    }
-    if (product.type !== ProductType.PLAN_PRODUCT) {
-        throw new ProductWrongTypeError({ type: product.type });
-    }
-    const enrollment = await this.enrollments.create({
-        billingAddress: billingAddress,
-        configuration: configuration ?? null,
-        contact: contact,
-        countryCode,
-        currencyCode,
-        delivery: delivery,
-        meta,
-        payment,
-        productId,
-        quantity: quantity ?? 1,
-        userId,
-    });
-    return initializeEnrollmentService.bind(this)(enrollment, {
-        orderIdForFirstPeriod: enrollment.orderIdForFirstPeriod,
-        reason: 'new_enrollment',
-    });
-}

package/lib/services/createProduct.d.ts

@@ -1,7 +0,0 @@
-import type { Product, ProductText } from '@unchainedshop/core-products';
-import type { Modules } from '../modules.ts';
-export interface CreateProductParams {
-    product: Partial<Product>;
-    texts?: ProductText[];
-}
-export declare function createProductService(this: Modules, params: CreateProductParams): Promise<Product>;

package/lib/services/createProduct.js

@@ -1,8 +0,0 @@
-export async function createProductService(params) {
-    const { product: productData, texts } = params;
-    const newProduct = await this.products.create(productData);
-    if (texts) {
-        await this.products.texts.updateTexts(newProduct._id, texts);
-    }
-    return newProduct;
-}

package/lib/services/createProductBundleItem.d.ts

@@ -1,5 +0,0 @@
-import { type Product, type ProductBundleItem } from '@unchainedshop/core-products';
-import type { Modules } from '../modules.ts';
-import { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError } from '../errors/index.ts';
-export { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError };
-export declare function createProductBundleItemService(this: Modules, productId: string, item: ProductBundleItem): Promise<Product | null>;

package/lib/services/createProductBundleItem.js

@@ -1,25 +0,0 @@
-import { ProductType } from '@unchainedshop/core-products';
-import { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError, } from "../errors/index.js";
-export { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError };
-export async function createProductBundleItemService(productId, item) {
-    const product = await this.products.findProduct({ productId });
-    if (!product) {
-        throw new ProductNotFoundError({ productId });
-    }
-    if (product.type !== ProductType.BUNDLE_PRODUCT) {
-        throw new ProductWrongTypeError({
-            productId,
-            received: product.type,
-            required: ProductType.BUNDLE_PRODUCT,
-        });
-    }
-    const itemProduct = await this.products.findProduct({ productId: item.productId });
-    if (!itemProduct) {
-        throw new ProductNotFoundError({ productId: item.productId });
-    }
-    if (itemProduct._id === product._id) {
-        throw new CyclicProductBundlingNotSupportedError({ productId: itemProduct._id });
-    }
-    await this.products.bundleItems.addBundleItem(productId, item);
-    return this.products.findProduct({ productId });
-}

package/lib/services/createProductReview.d.ts

@@ -1,8 +0,0 @@
-import type { ProductReview } from '@unchainedshop/core-products';
-import type { Modules } from '../modules.ts';
-export interface CreateProductReviewParams {
-    productId: string;
-    authorId: string;
-    productReview: Pick<ProductReview, 'title' | 'rating' | 'meta'>;
-}
-export declare function createProductReviewService(this: Modules, params: CreateProductReviewParams): Promise<ProductReview>;

package/lib/services/createProductReview.js

@@ -1,12 +0,0 @@
-import { ProductNotFoundError } from "../errors/index.js";
-export async function createProductReviewService(params) {
-    const { productId, authorId, productReview } = params;
-    if (!(await this.products.productExists({ productId }))) {
-        throw new ProductNotFoundError({ productId });
-    }
-    return this.products.reviews.create({
-        ...productReview,
-        productId,
-        authorId,
-    });
-}

package/lib/services/deleteDeadCarts.d.ts

@@ -1,2 +0,0 @@
-import type { Modules } from '../modules.ts';
-export declare function deleteDeadCartsService(this: Modules): Promise<number>;

package/lib/services/deleteDeadCarts.js

@@ -1,17 +0,0 @@
-import { deleteCartService } from "./deleteCart.js";
-export async function deleteDeadCartsService() {
-    const cartUserIds = (await this.orders.findCartUserIds()).filter(Boolean);
-    if (!cartUserIds.length)
-        return 0;
-    const existingUserIds = new Set(await this.users.findExistingUserIds({ userIds: cartUserIds }));
-    const deadUserIds = cartUserIds.filter((userId) => !existingUserIds.has(userId));
-    if (!deadUserIds.length)
-        return 0;
-    const deadCarts = await this.orders.findCarts({ userIds: deadUserIds }, { projection: { _id: 1 } });
-    let deletedCount = 0;
-    await Array.fromAsync(deadCarts, async (cart) => {
-        await deleteCartService.bind(this)(cart._id);
-        deletedCount += 1;
-    });
-    return deletedCount;
-}

package/lib/services/deliverOrder.d.ts

@@ -1,5 +0,0 @@
-import { type Order } from '@unchainedshop/core-orders';
-import type { Modules } from '../modules.ts';
-import { OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError } from '../errors/index.ts';
-export { OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError };
-export declare function deliverOrderService(this: Modules, orderId: string): Promise<Order>;

package/lib/services/deliverOrder.js

@@ -1,26 +0,0 @@
-import { OrderDeliveryStatus } from '@unchainedshop/core-orders';
-import { processOrderService } from "./processOrder.js";
-import { OrderNotFoundError, OrderWrongStatusError, OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError, } from "../errors/index.js";
-export { OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError };
-export async function deliverOrderService(orderId) {
-    const order = await this.orders.findOrder({ orderId });
-    if (!order) {
-        throw new OrderNotFoundError({ orderId });
-    }
-    if (this.orders.isCart(order)) {
-        throw new OrderWrongStatusError({ status: order.status });
-    }
-    const orderDelivery = order.deliveryId &&
-        (await this.orders.deliveries.findDelivery({
-            orderDeliveryId: order.deliveryId,
-        }));
-    if (!orderDelivery) {
-        throw new OrderDeliveryNotFoundError({ orderDeliveryId: order.deliveryId });
-    }
-    if (this.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN &&
-        order.confirmed) {
-        throw new OrderWrongDeliveryStatusError({ status: orderDelivery.status });
-    }
-    await this.orders.deliveries.markAsDelivered(orderDelivery);
-    return processOrderService.bind(this)(order, {});
-}

package/lib/services/findActiveWorkTypes.d.ts

@@ -1,2 +0,0 @@
-import type { Modules } from '../modules.ts';
-export declare function findActiveWorkTypesService(this: Modules): Promise<string[]>;

package/lib/services/findActiveWorkTypes.js

@@ -1,6 +0,0 @@
-import { WorkerDirector } from "../directors/index.js";
-export async function findActiveWorkTypesService() {
-    const typeList = await this.worker.activeWorkTypes();
-    const pluginTypes = WorkerDirector.getActivePluginTypes();
-    return typeList.filter((type) => pluginTypes.includes(type));
-}

package/lib/services/findDeliveryInterfaces.d.ts

@@ -1,7 +0,0 @@
-import { DeliveryProviderType } from '@unchainedshop/core-delivery';
-export interface DeliveryInterface {
-    _id: string;
-    label: string;
-    version: string;
-}
-export declare function findDeliveryInterfacesService(type?: DeliveryProviderType): Promise<DeliveryInterface[]>;

package/lib/services/findDeliveryInterfaces.js

@@ -1,13 +0,0 @@
-import { DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryDirector } from "../directors/index.js";
-export async function findDeliveryInterfacesService(type) {
-    const allAdapters = await DeliveryDirector.getAdapters();
-    const filteredAdapters = type
-        ? allAdapters.filter((Adapter) => Adapter.typeSupported(type))
-        : allAdapters;
-    return filteredAdapters.map((Adapter) => ({
-        _id: Adapter.key,
-        label: Adapter.label,
-        version: Adapter.version,
-    }));
-}

package/lib/services/findOrdersWithFilters.d.ts

@@ -1,9 +0,0 @@
-import type { Order, OrderQuery } from '@unchainedshop/core-orders';
-import type { SortOption } from '@unchainedshop/utils';
-import type { Modules } from '../modules.ts';
-export interface FindOrdersWithFiltersParams extends OrderQuery {
-    limit?: number;
-    offset?: number;
-    sort?: SortOption[];
-}
-export declare function findOrdersWithFiltersService(this: Modules, params: FindOrdersWithFiltersParams): Promise<Order[]>;