@unchainedshop/api 4.8.25 → 4.8.27

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

@@ -0,0 +1,18 @@
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError, AssortmentNotFoundError } from "../../../errors.js";
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkAssignProductsToAssortment(root, { productIds, assortmentId }, { modules, services, userId }) {
+    log(`mutation bulkAssignProductsToAssortment ${assortmentId} for ${productIds.length} products`, {
+        userId,
+    });
+    const normalizedProductIds = normalizeBulkIds(productIds);
+    if (!assortmentId)
+        throw new InvalidIdError({ assortmentId });
+    if (!(await modules.assortments.assortmentExists({ assortmentId })))
+        throw new AssortmentNotFoundError({ assortmentId });
+    const result = await services.assortments.bulkAssignProductsToAssortment({
+        assortmentId,
+        productIds: normalizedProductIds,
+    });
+    return createBulkOperationResult(result);
+}

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

@@ -0,0 +1,12 @@
+export declare const MAX_BULK_OPERATION_SIZE = 1000;
+export interface BulkOperationIds {
+    successIds: string[];
+    failedIds: string[];
+}
+export declare const normalizeBulkIds: (ids: readonly string[]) => string[];
+export declare const createBulkOperationResult: ({ successIds, failedIds }: BulkOperationIds) => {
+    successIds: string[];
+    successCount: number;
+    failedIds: string[];
+    failedCount: number;
+};

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

@@ -0,0 +1,14 @@
+import { BulkOperationTooLargeError } from "../../../errors.js";
+export const MAX_BULK_OPERATION_SIZE = 1000;
+export const normalizeBulkIds = (ids) => {
+    if (ids.length > MAX_BULK_OPERATION_SIZE) {
+        throw new BulkOperationTooLargeError({ limit: MAX_BULK_OPERATION_SIZE });
+    }
+    return [...new Set(ids)];
+};
+export const createBulkOperationResult = ({ successIds, failedIds }) => ({
+    successIds,
+    successCount: successIds.length,
+    failedIds,
+    failedCount: failedIds.length,
+});

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

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

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

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

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

@@ -0,0 +1,9 @@
+import type { Context } from '../../../context.ts';
+export default function bulkRemoveFilters(root: never, { filterIds }: {
+    filterIds: string[];
+}, { services, userId }: Context): Promise<{
+    successIds: string[];
+    successCount: number;
+    failedIds: string[];
+    failedCount: number;
+}>;

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

@@ -0,0 +1,9 @@
+import { log } from '@unchainedshop/logger';
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkRemoveFilters(root, { filterIds }, { services, userId }) {
+    log(`mutation bulkRemoveFilters for ${filterIds.length} filters`, { userId });
+    const result = await services.filters.bulkRemoveFilters({
+        filterIds: normalizeBulkIds(filterIds),
+    });
+    return createBulkOperationResult(result);
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import type { Context } from '../../../context.ts';
+export default function bulkSetAssortmentActive(root: never, { assortmentIds, isActive }: {
+    assortmentIds: string[];
+    isActive: boolean;
+}, { modules, userId }: Context): Promise<{
+    successIds: string[];
+    successCount: number;
+    failedIds: string[];
+    failedCount: number;
+}>;

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

@@ -0,0 +1,9 @@
+import { log } from '@unchainedshop/logger';
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkSetAssortmentActive(root, { assortmentIds, isActive }, { modules, userId }) {
+    log(`mutation bulkSetAssortmentActive ${isActive} for ${assortmentIds.length} assortments`, {
+        userId,
+    });
+    const result = await modules.assortments.bulkSetActive(normalizeBulkIds(assortmentIds), isActive);
+    return createBulkOperationResult(result);
+}

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

@@ -0,0 +1,10 @@
+import type { Context } from '../../../context.ts';
+export default function bulkSetFilterActive(root: never, { filterIds, isActive }: {
+    filterIds: string[];
+    isActive: boolean;
+}, { services, userId }: Context): Promise<{
+    successIds: string[];
+    successCount: number;
+    failedIds: string[];
+    failedCount: number;
+}>;

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

@@ -0,0 +1,10 @@
+import { log } from '@unchainedshop/logger';
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkSetFilterActive(root, { filterIds, isActive }, { services, userId }) {
+    log(`mutation bulkSetFilterActive ${isActive} for ${filterIds.length} filters`, { userId });
+    const result = await services.filters.bulkSetFilterActive({
+        filterIds: normalizeBulkIds(filterIds),
+        isActive,
+    });
+    return createBulkOperationResult(result);
+}

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

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

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

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkSetProductStatus(root, { productIds, status }, { modules, userId }) {
+    log(`mutation bulkSetProductStatus ${status} for ${productIds.length} products`, { userId });
+    const normalizedProductIds = normalizeBulkIds(productIds);
+    let result;
+    if (status === 'ACTIVE') {
+        result = await modules.products.bulkPublish(normalizedProductIds);
+    }
+    else if (status === 'DRAFT') {
+        result = await modules.products.bulkUnpublish(normalizedProductIds);
+    }
+    else {
+        result = { successIds: [], failedIds: normalizedProductIds };
+    }
+    return createBulkOperationResult(result);
+}

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

@@ -0,0 +1,10 @@
+import type { Context } from '../../../context.ts';
+export default function bulkSetUserRoles(root: never, { userIds, roles }: {
+    userIds: string[];
+    roles: string[];
+}, context: Context): Promise<{
+    successIds: string[];
+    successCount: number;
+    failedIds: string[];
+    failedCount: number;
+}>;

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

@@ -0,0 +1,14 @@
+import { log } from '@unchainedshop/logger';
+import { getPublicRoles } from "../../../roles/index.js";
+import { createBulkOperationResult, normalizeBulkIds } from "./bulkOperation.js";
+export default async function bulkSetUserRoles(root, { userIds, roles }, context) {
+    const { modules, userId } = context;
+    log(`mutation bulkSetUserRoles for ${userIds.length} users`, { userId });
+    const publicRoles = getPublicRoles(context.roles);
+    const invalidRoles = roles.filter((r) => !publicRoles.includes(r));
+    if (invalidRoles.length) {
+        throw new Error(`Invalid role names: ${invalidRoles.join(', ')}`);
+    }
+    const result = await modules.users.bulkUpdateRoles(normalizeBulkIds(userIds), roles);
+    return createBulkOperationResult(result);
+}

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

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

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

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

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/mutations/users/removeUser.js

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { UserNotFoundError } from "../../../errors.js";
+import { LastAdminError, UserNotFoundError } from "../../../errors.js";
 export default async function removeUser(root, params, { modules, services, userId: currentUserId }) {
     const { userId: paramUserId, removeUserReviews = false } = params;
     const normalizedUserId = paramUserId || currentUserId;
@@ -9,5 +9,12 @@ export default async function removeUser(root, params, { modules, services, user
     if (removeUserReviews) {
         await modules.products.reviews.deleteByAuthorId(normalizedUserId);
     }
-    return services.users.deleteUser({ userId: normalizedUserId });
+    try {
+        return await services.users.deleteUser({ userId: normalizedUserId });
+    }
+    catch (e) {
+        if (e.cause === 'LAST_ADMIN')
+            throw new LastAdminError({ userId: normalizedUserId });
+        throw e;
+    }
 }

package/lib/resolvers/mutations/users/setRoles.js

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
 import { Roles } from '@unchainedshop/roles';
-import { InvalidIdError, UserNotFoundError } from "../../../errors.js";
+import { InvalidIdError, LastAdminError, UserNotFoundError } from "../../../errors.js";
 export default async function setRoles(root, params, { modules, userId }) {
     const foreignUserId = params.userId;
     log(`mutation setRoles ${foreignUserId}`, { userId });
@@ -12,5 +12,12 @@ export default async function setRoles(root, params, { modules, userId }) {
     if (invalidRoles.length > 0) {
         throw new Error(`Invalid role names: ${invalidRoles.join(', ')}`);
     }
-    return modules.users.updateRoles(foreignUserId, params.roles);
+    try {
+        return await modules.users.updateRoles(foreignUserId, params.roles);
+    }
+    catch (e) {
+        if (e.cause === 'LAST_ADMIN')
+            throw new LastAdminError({ userId: foreignUserId });
+        throw e;
+    }
 }

package/lib/resolvers/mutations/worker/allocateWork.d.ts

@@ -2,4 +2,4 @@ import type { Context } from '../../../context.ts';
 export default function allocateWork(root: never, { types, worker }: {
     types: string[];
     worker: string;
-}, { modules, userId }: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-worker").Work> | null>;
+}, context: Context): Promise<import("@unchainedshop/core-worker").Work | null>;

package/lib/resolvers/mutations/worker/allocateWork.js

@@ -1,7 +1,8 @@
 import { log } from '@unchainedshop/logger';
-export default async function allocateWork(root, { types, worker }, { modules, userId }) {
+import { WorkerDirector } from '@unchainedshop/core';
+export default async function allocateWork(root, { types, worker }, context) {
     log(`mutation allocateWork ${(types || []).join(',')} ${worker}`, {
-        userId,
+        userId: context.userId,
     });
-    return modules.worker.allocateWork({ types, worker });
+    return WorkerDirector.allocateWork(context, { types, worker });
 }

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/schema/types/common.js

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