@unchainedshop/api 4.8.26 → 4.8.27

package/lib/resolvers/mutations/bulk/bulkUpdateProductTags.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '../../../context.ts';
+export default function bulkUpdateProductTags(root: never, { productIds, add, remove }: {
+    productIds: string[];
+    add?: string[];
+    remove?: string[];
+}, { modules, userId }: Context): Promise<{
+    successIds: string[];
+    successCount: number;
+    failedIds: string[];
+    failedCount: number;
+}>;

package/lib/resolvers/mutations/bulk/bulkUpdateProductTags.js

@@ -0,0 +1,7 @@
+import { log } from '@unchainedshop/logger';
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkUpdateProductTags(root, { productIds, add, remove }, { modules, userId }) {
+    log(`mutation bulkUpdateProductTags for ${productIds.length} products`, { userId });
+    const result = await modules.products.bulkUpdateTags(normalizeBulkIds(productIds), { add, remove });
+    return createBulkOperationResult(result);
+}

package/lib/resolvers/mutations/bulk/bulkUpdateUserTags.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '../../../context.ts';
+export default function bulkUpdateUserTags(root: never, { userIds, add, remove }: {
+    userIds: string[];
+    add?: string[];
+    remove?: string[];
+}, { modules, userId }: Context): Promise<{
+    successIds: string[];
+    successCount: number;
+    failedIds: string[];
+    failedCount: number;
+}>;

package/lib/resolvers/mutations/bulk/bulkUpdateUserTags.js

@@ -0,0 +1,7 @@
+import { log } from '@unchainedshop/logger';
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkUpdateUserTags(root, { userIds, add, remove }, { modules, userId }) {
+    log(`mutation bulkUpdateUserTags for ${userIds.length} users`, { userId });
+    const result = await modules.users.bulkUpdateTags(normalizeBulkIds(userIds), { add, remove });
+    return createBulkOperationResult(result);
+}

package/lib/resolvers/queries/search/globalSearch.d.ts

@@ -0,0 +1,36 @@
+import type { Context } from '../../../context.ts';
+import type { Product } from '@unchainedshop/core-products';
+import type { User } from '@unchainedshop/core-users';
+import type { Order } from '@unchainedshop/core-orders';
+import type { Assortment } from '@unchainedshop/core-assortments';
+import type { Filter } from '@unchainedshop/core-filters';
+import type { Enrollment } from '@unchainedshop/core-enrollments';
+import type { Quotation } from '@unchainedshop/core-quotations';
+import type { Work } from '@unchainedshop/core-worker';
+type SearchableEntity = 'PRODUCT' | 'USER' | 'ORDER' | 'ASSORTMENT' | 'FILTER' | 'ENROLLMENT' | 'QUOTATION' | 'WORK';
+interface TypeLimitInput {
+    type: SearchableEntity;
+    limit: number;
+}
+type SearchResultItem = (Product | User | Order | Assortment | Filter | Enrollment | Quotation | Work) & {
+    __typename: string;
+};
+export default function globalSearch(root: never, params: {
+    query: string;
+    types?: SearchableEntity[];
+    limit?: number;
+    typeLimits?: TypeLimitInput[];
+    includeDraftProducts?: boolean;
+    includeInactiveAssortments?: boolean;
+    includeInactiveFilters?: boolean;
+    includeGuestUsers?: boolean;
+    includeCarts?: boolean;
+}, context: Context): Promise<{
+    results: SearchResultItem[];
+    counts: {
+        type: SearchableEntity;
+        totalCount: number;
+        authorized: boolean;
+    }[];
+}>;
+export {};

package/lib/resolvers/queries/search/globalSearch.js

@@ -0,0 +1,200 @@
+import { log } from '@unchainedshop/logger';
+import { checkAction } from "../../../acl.js";
+import { actions } from "../../../roles/index.js";
+const ALL_TYPES = [
+    'PRODUCT',
+    'USER',
+    'ORDER',
+    'ASSORTMENT',
+    'FILTER',
+    'ENROLLMENT',
+    'QUOTATION',
+    'WORK',
+];
+const DEFAULT_LIMIT = 5;
+const MAX_LIMIT = 50;
+const typeActionMap = {
+    PRODUCT: actions.viewProducts,
+    USER: actions.viewUsers,
+    ORDER: actions.viewOrders,
+    ASSORTMENT: actions.viewAssortments,
+    FILTER: actions.viewFilters,
+    ENROLLMENT: actions.viewEnrollments,
+    QUOTATION: actions.viewQuotations,
+    WORK: actions.viewWorkQueue,
+};
+function getLimitForType(type, defaultLimit, typeLimits) {
+    const requestedLimit = typeLimits?.find((typeLimit) => typeLimit.type === type)?.limit ?? defaultLimit;
+    return Math.min(MAX_LIMIT, Math.max(1, requestedLimit));
+}
+function getSearchParams(type, queryString, limit, options) {
+    switch (type) {
+        case 'PRODUCT':
+            return {
+                queryString,
+                limit,
+                offset: 0,
+                includeDrafts: options.includeDraftProducts,
+            };
+        case 'USER':
+            return {
+                queryString,
+                limit,
+                offset: 0,
+                includeGuests: options.includeGuestUsers,
+            };
+        case 'ORDER':
+            return {
+                queryString,
+                limit,
+                offset: 0,
+                includeCarts: options.includeCarts,
+            };
+        case 'ASSORTMENT':
+            return {
+                queryString,
+                limit,
+                offset: 0,
+                includeInactive: options.includeInactiveAssortments,
+            };
+        case 'FILTER':
+            return {
+                queryString,
+                limit,
+                offset: 0,
+                includeInactive: options.includeInactiveFilters,
+            };
+        case 'ENROLLMENT':
+        case 'QUOTATION':
+            return { queryString, limit, offset: 0 };
+        case 'WORK':
+            return { queryString, limit, skip: 0 };
+    }
+}
+const typeNameMap = {
+    PRODUCT: 'Product',
+    USER: 'User',
+    ORDER: 'Order',
+    ASSORTMENT: 'Assortment',
+    FILTER: 'Filter',
+    ENROLLMENT: 'Enrollment',
+    QUOTATION: 'Quotation',
+    WORK: 'Work',
+};
+async function searchType(type, queryString, limit, modules, options) {
+    let results;
+    switch (type) {
+        case 'PRODUCT':
+            results = await modules.products.findProducts({
+                queryString,
+                limit,
+                offset: 0,
+                includeDrafts: options.includeDraftProducts,
+            });
+            break;
+        case 'USER':
+            results = await modules.users.findUsers({
+                queryString,
+                limit,
+                offset: 0,
+                includeGuests: options.includeGuestUsers,
+            });
+            break;
+        case 'ORDER':
+            results = await modules.orders.findOrders({
+                queryString,
+                limit,
+                offset: 0,
+                includeCarts: options.includeCarts,
+            });
+            break;
+        case 'ASSORTMENT':
+            results = await modules.assortments.findAssortments({
+                queryString,
+                limit,
+                offset: 0,
+                includeInactive: options.includeInactiveAssortments,
+            });
+            break;
+        case 'FILTER':
+            results = await modules.filters.findFilters({
+                queryString,
+                limit,
+                offset: 0,
+                includeInactive: options.includeInactiveFilters,
+            });
+            break;
+        case 'ENROLLMENT':
+            results = await modules.enrollments.findEnrollments({ queryString, limit, offset: 0 });
+            break;
+        case 'QUOTATION':
+            results = await modules.quotations.findQuotations({ queryString, limit, offset: 0 });
+            break;
+        case 'WORK':
+            results = await modules.worker.findWorkQueue({ queryString, limit, skip: 0 });
+            break;
+        default:
+            return [];
+    }
+    const __typename = typeNameMap[type];
+    return results.map((r) => ({ ...r, __typename }));
+}
+async function countType(type, queryString, modules, options) {
+    switch (type) {
+        case 'PRODUCT':
+            return modules.products.count({ queryString, includeDrafts: options.includeDraftProducts });
+        case 'USER':
+            return modules.users.count({ queryString, includeGuests: options.includeGuestUsers });
+        case 'ORDER':
+            return modules.orders.count({ queryString, includeCarts: options.includeCarts });
+        case 'ASSORTMENT':
+            return modules.assortments.count({
+                queryString,
+                includeInactive: options.includeInactiveAssortments,
+            });
+        case 'FILTER':
+            return modules.filters.count({ queryString, includeInactive: options.includeInactiveFilters });
+        case 'ENROLLMENT':
+            return modules.enrollments.count({ queryString });
+        case 'QUOTATION':
+            return modules.quotations.count({ queryString });
+        case 'WORK':
+            return modules.worker.count({ queryString });
+        default:
+            return 0;
+    }
+}
+async function checkTypeAuthorization(context, root, types, queryString, defaultLimit, typeLimits, options) {
+    await Promise.all(types.map((type) => checkAction(context, typeActionMap[type], [
+        root,
+        getSearchParams(type, queryString, getLimitForType(type, defaultLimit, typeLimits), options),
+    ])));
+}
+export default async function globalSearch(root, params, context) {
+    const { query: queryString, types, limit = DEFAULT_LIMIT, typeLimits, includeDraftProducts = true, includeInactiveAssortments = true, includeInactiveFilters = true, includeGuestUsers = false, includeCarts = false, } = params;
+    const { modules, userId } = context;
+    const sanitizedQuery = queryString?.trim().slice(0, 200) || '';
+    const requestedTypes = [...new Set(types?.length ? types : ALL_TYPES)];
+    const searchOptions = {
+        includeDraftProducts,
+        includeInactiveAssortments,
+        includeInactiveFilters,
+        includeGuestUsers,
+        includeCarts,
+    };
+    await checkTypeAuthorization(context, root, requestedTypes, sanitizedQuery, limit, typeLimits, searchOptions);
+    if (!sanitizedQuery)
+        return { results: [], counts: [] };
+    log(`query globalSearch: "${sanitizedQuery}" types: ${requestedTypes.join(',')}`, { userId });
+    const [resultsByType, countsByType] = await Promise.all([
+        Promise.all(requestedTypes.map((type) => searchType(type, sanitizedQuery, getLimitForType(type, limit, typeLimits), modules, searchOptions))),
+        Promise.all(requestedTypes.map((type) => countType(type, sanitizedQuery, modules, searchOptions))),
+    ]);
+    const results = resultsByType.flat();
+    const counts = requestedTypes.map((type, i) => ({
+        type,
+        totalCount: countsByType[i],
+        authorized: true,
+    }));
+    return { results, counts };
+}

package/lib/resolvers/type/global-search-result-types.d.ts

@@ -0,0 +1,3 @@
+export declare const GlobalSearchResult: {
+    __resolveType(obj: Record<string, any>): string;
+};

package/lib/resolvers/type/global-search-result-types.js

@@ -0,0 +1,15 @@
+import { ProductType } from '@unchainedshop/core-products';
+const productTypeMap = {
+    [ProductType.CONFIGURABLE_PRODUCT]: 'ConfigurableProduct',
+    [ProductType.BUNDLE_PRODUCT]: 'BundleProduct',
+    [ProductType.PLAN_PRODUCT]: 'PlanProduct',
+    [ProductType.TOKENIZED_PRODUCT]: 'TokenizedProduct',
+};
+export const GlobalSearchResult = {
+    __resolveType(obj) {
+        if (obj.__typename === 'Product') {
+            return productTypeMap[obj.type] || 'SimpleProduct';
+        }
+        return obj.__typename;
+    },
+};

package/lib/resolvers/type/order/order-payment-base.d.ts

@@ -0,0 +1,7 @@
+import type { OrderPayment } from '@unchainedshop/core-orders';
+import type { Context } from '../../../context.ts';
+export declare const OrderPaymentBase: {
+    status(obj: OrderPayment, _: never, { modules }: Context): import("@unchainedshop/core-orders").OrderPaymentStatus;
+    provider(obj: OrderPayment, _: never, { loaders }: Context): Promise<import("@unchainedshop/core-payment").PaymentProvider>;
+    discounts(obj: OrderPayment, _: never, { loaders, services }: Context): Promise<import("@unchainedshop/core/lib/services/getPaymentDiscounts.js").PaymentDiscountPrice[]>;
+};

package/lib/resolvers/type/order/order-payment-base.js

@@ -0,0 +1,14 @@
+export const OrderPaymentBase = {
+    status(obj, _, { modules }) {
+        return modules.orders.payments.normalizedStatus(obj);
+    },
+    async provider(obj, _, { loaders }) {
+        return loaders.paymentProviderLoader.load({
+            paymentProviderId: obj.paymentProviderId,
+        });
+    },
+    async discounts(obj, _, { loaders, services }) {
+        const order = await loaders.orderLoader.load({ orderId: obj.orderId });
+        return services.payment.getPaymentDiscounts(obj, order.currencyCode);
+    },
+};

package/lib/schema/types/common.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/lib/schema/types/common.js

@@ -0,0 +1,19 @@
+export default [
+    `
+    type SuccessResponse @cacheControl(maxAge: 0, scope: PRIVATE) {
+      success: Boolean
+    }
+
+    type BulkOperationResult @cacheControl(maxAge: 0, scope: PRIVATE) {
+      successIds: [ID!]!
+      successCount: Int!
+      failedCount: Int!
+      failedIds: [ID!]!
+    }
+
+    enum SortDirection {
+      ASC
+      DESC
+    }
+  `,
+];

package/lib/utils/mapServiceError.d.ts

@@ -0,0 +1 @@
+export declare function mapServiceError(error: unknown): never;

package/lib/utils/mapServiceError.js

@@ -0,0 +1,59 @@
+import { GraphQLError } from 'graphql';
+import * as errors from "../errors.js";
+const errorMap = {
+    ProductNotFoundError: errors.ProductNotFoundError,
+    ProductWrongStatusError: errors.ProductWrongStatusError,
+    ProductWrongTypeError: errors.ProductWrongTypeError,
+    CyclicProductBundlingNotSupportedError: errors.CyclicProductBundlingNotSupportedError,
+    ProductVariationInfinityLoop: errors.ProductVariationInfinityLoop,
+    ProductVariationVectorInvalid: errors.ProductVariationVectorInvalid,
+    ProductVariationVectorAlreadySet: errors.ProductVariationVectorAlreadySet,
+    ProductLinkedToActiveBundleError: errors.ProductLinkedToActiveBundleError,
+    ProductLinkedToActiveVariationError: errors.ProductLinkedToActiveVariationError,
+    ProductLinkedToQuotationError: errors.ProductLinkedToQuotationError,
+    ProductLinkedToEnrollmentError: errors.ProductLinkedToEnrollmentError,
+    EnrollmentNotFoundError: errors.EnrollmentNotFoundError,
+    EnrollmentWrongStatusError: errors.EnrollmentWrongStatusError,
+    EnrollmentPlanUpdateNotAllowedError: errors.EnrollmentWrongStatusError,
+    OrderNotFoundError: errors.OrderNotFoundError,
+    OrderWrongStatusError: errors.OrderWrongStatusError,
+    OrderItemNotFoundError: errors.OrderItemNotFoundError,
+    OrderQuantityTooLowError: errors.OrderQuantityTooLowError,
+    OrderPaymentNotFoundError: errors.OrderPaymentNotFoundError,
+    OrderWrongPaymentStatusError: errors.OrderWrongPaymentStatusError,
+    OrderDeliveryNotFoundError: errors.OrderDeliveryNotFoundError,
+    OrderWrongDeliveryStatusError: errors.OrderWrongDeliveryStatusError,
+    QuotationNotFoundError: errors.QuotationNotFoundError,
+    QuotationWrongStatusError: errors.QuotationWrongStatusError,
+    QuotationItemConfigurationError: errors.QuotationItemConfigurationError,
+    BookmarkNotFoundError: errors.BookmarkNotFoundError,
+    MultipleBookmarksFound: errors.MultipleBookmarksFound,
+    BookmarkAlreadyExistsError: errors.BookmarkAlreadyExistsError,
+    OrderDiscountCodeAlreadyPresentError: errors.OrderDiscountCodeAlreadyPresentError,
+    OrderDiscountCodeNotValidError: errors.OrderDiscountCodeNotValidError,
+    UserNotFoundError: errors.UserNotFoundError,
+    ImpersonatingAdminUserError: errors.ImpersonatingAdminUserError,
+    InvalidEmailVerificationTokenError: errors.InvalidEmailVerificationTokenError,
+    UsernameOrEmailRequiredError: errors.UsernameOrEmailRequiredError,
+    PasswordOrWebAuthnPublicKeyRequiredError: errors.PasswordOrWebAuthnPublicKeyRequiredError,
+    EmailAlreadyExistsError: errors.EmailAlreadyExistsError,
+    UsernameAlreadyExistsError: errors.UsernameAlreadyExistsError,
+    PasswordInvalidError: errors.PasswordInvalidError,
+    WebAuthnVerificationFailedError: errors.WebAuthnVerificationFailedError,
+    AuthOperationFailedError: errors.AuthOperationFailedError,
+    InvalidCredentialsError: errors.InvalidCredentialsError,
+    InvalidResetTokenError: errors.InvalidResetTokenError,
+    InvalidIdError: errors.InvalidIdError,
+    ProviderConfigurationInvalid: errors.ProviderConfigurationInvalid,
+};
+export function mapServiceError(error) {
+    if (error instanceof GraphQLError) {
+        throw error;
+    }
+    const serviceError = error;
+    const ErrorClass = serviceError.code ? errorMap[serviceError.code] : undefined;
+    if (ErrorClass) {
+        throw new ErrorClass(serviceError.data);
+    }
+    throw error;
+}

package/lib/utils/maskError.d.ts

@@ -0,0 +1 @@
+export declare function createMaskError(isDev: boolean): (error: unknown, message: string) => Error;

package/lib/utils/maskError.js

@@ -0,0 +1,22 @@
+import { GraphQLError } from 'graphql';
+import { maskError as yogaMaskError } from 'graphql-yoga';
+function isKnownError(error) {
+    return error instanceof Error && 'code' in error && typeof error.code === 'string';
+}
+export function createMaskError(isDev) {
+    return function maskError(error, message) {
+        const originalError = error instanceof GraphQLError ? error.originalError || error : error;
+        if (error instanceof GraphQLError && error.extensions?.code) {
+            return error;
+        }
+        if (isKnownError(originalError)) {
+            return new GraphQLError(originalError.message, {
+                extensions: {
+                    code: originalError.code,
+                    ...(originalError.data || {}),
+                },
+            });
+        }
+        return yogaMaskError(error, message, isDev);
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/api",
   "description": "GraphQL API layer for the Unchained Engine with Express/Fastify adapters and MCP server",
-  "version": "4.8.26",
+  "version": "4.8.27",
   "main": "lib/api-index.js",
   "types": "lib/api-index.d.ts",
   "type": "module",
@@ -125,29 +125,29 @@
   },
   "dependencies": {
     "@envelop/core": "^5.6.0",
-    "@unchainedshop/core": "^4.8.12",
-    "@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/logger": "^4.8.12",
-    "@unchainedshop/mongodb": "^4.8.12",
-    "@unchainedshop/roles": "^4.8.12",
-    "@unchainedshop/utils": "^4.8.12",
+    "@unchainedshop/core": "^4.8.27",
+    "@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/logger": "^4.8.27",
+    "@unchainedshop/mongodb": "^4.8.27",
+    "@unchainedshop/roles": "^4.8.27",
+    "@unchainedshop/utils": "^4.8.27",
     "dataloader": "^2.2.3",
     "graphql-scalars": "^2.0.0",
     "mime": ">= 4 < 5",