@voyantjs/products 0.3.1 → 0.4.0

package/dist/service-public.d.ts

@@ -1,5 +1,5 @@
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import type { PublicCatalogCategoryListQuery, PublicCatalogProductListQuery, PublicCatalogProductLookupBySlugQuery, PublicCatalogTagListQuery } from "./validation-public.js";
+import type { PublicCatalogCategoryListQuery, PublicCatalogDestinationListQuery, PublicCatalogProductListQuery, PublicCatalogProductLookupBySlugQuery, PublicCatalogTagListQuery } from "./validation-public.js";
 export declare const publicProductsService: {
     listCatalogProducts(db: PostgresJsDatabase, query: PublicCatalogProductListQuery): Promise<{
         data: ({
@@ -38,6 +38,28 @@ export declare const publicProductsService: {
                 name: string;
             }[];
             capabilities: string[];
+            destinations: {
+                id: string;
+                parentId: string | null;
+                slug: string;
+                name: string;
+                description: string | null;
+                seoTitle: string | null;
+                seoDescription: string | null;
+                destinationType: string;
+                sortOrder: number;
+            }[];
+            locations: {
+                id: string;
+                locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
+                title: string;
+                address: string | null;
+                city: string | null;
+                countryCode: string | null;
+                latitude: number | null;
+                longitude: number | null;
+                sortOrder: number;
+            }[];
             coverMedia: {
                 id: string;
                 mediaType: "image" | "video" | "document";
@@ -47,9 +69,25 @@ export declare const publicProductsService: {
                 altText: string | null;
                 sortOrder: number;
                 isCover: boolean;
+                isBrochure: boolean;
+                isBrochureCurrent: boolean;
+                brochureVersion: number | null;
             } | null;
             isFeatured: boolean;
         } | {
+            brochure: {
+                id: string;
+                mediaType: "image" | "video" | "document";
+                name: string;
+                url: string;
+                mimeType: string | null;
+                altText: string | null;
+                sortOrder: number;
+                isCover: boolean;
+                isBrochure: boolean;
+                isBrochureCurrent: boolean;
+                brochureVersion: number | null;
+            } | null;
             media: {
                 id: string;
                 mediaType: "image" | "video" | "document";
@@ -59,6 +97,9 @@ export declare const publicProductsService: {
                 altText: string | null;
                 sortOrder: number;
                 isCover: boolean;
+                isBrochure: boolean;
+                isBrochureCurrent: boolean;
+                brochureVersion: number | null;
             }[];
             features: {
                 id: string;
@@ -73,17 +114,6 @@ export declare const publicProductsService: {
                 answer: string;
                 sortOrder: number;
             }[];
-            locations: {
-                id: string;
-                locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
-                title: string;
-                address: string | null;
-                city: string | null;
-                countryCode: string | null;
-                latitude: number | null;
-                longitude: number | null;
-                sortOrder: number;
-            }[];
             id: string;
             name: string;
             description: string | null;
@@ -119,6 +149,28 @@ export declare const publicProductsService: {
                 name: string;
             }[];
             capabilities: string[];
+            destinations: {
+                id: string;
+                parentId: string | null;
+                slug: string;
+                name: string;
+                description: string | null;
+                seoTitle: string | null;
+                seoDescription: string | null;
+                destinationType: string;
+                sortOrder: number;
+            }[];
+            locations: {
+                id: string;
+                locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
+                title: string;
+                address: string | null;
+                city: string | null;
+                countryCode: string | null;
+                latitude: number | null;
+                longitude: number | null;
+                sortOrder: number;
+            }[];
             coverMedia: {
                 id: string;
                 mediaType: "image" | "video" | "document";
@@ -128,6 +180,9 @@ export declare const publicProductsService: {
                 altText: string | null;
                 sortOrder: number;
                 isCover: boolean;
+                isBrochure: boolean;
+                isBrochureCurrent: boolean;
+                brochureVersion: number | null;
             } | null;
             isFeatured: boolean;
         })[];
@@ -173,6 +228,28 @@ export declare const publicProductsService: {
             name: string;
         }[];
         capabilities: string[];
+        destinations: {
+            id: string;
+            parentId: string | null;
+            slug: string;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            destinationType: string;
+            sortOrder: number;
+        }[];
+        locations: {
+            id: string;
+            locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
+            title: string;
+            address: string | null;
+            city: string | null;
+            countryCode: string | null;
+            latitude: number | null;
+            longitude: number | null;
+            sortOrder: number;
+        }[];
         coverMedia: {
             id: string;
             mediaType: "image" | "video" | "document";
@@ -182,6 +259,9 @@ export declare const publicProductsService: {
             altText: string | null;
             sortOrder: number;
             isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
         } | null;
         isFeatured: boolean;
     } | null>;
@@ -221,6 +301,28 @@ export declare const publicProductsService: {
             name: string;
         }[];
         capabilities: string[];
+        destinations: {
+            id: string;
+            parentId: string | null;
+            slug: string;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            destinationType: string;
+            sortOrder: number;
+        }[];
+        locations: {
+            id: string;
+            locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
+            title: string;
+            address: string | null;
+            city: string | null;
+            countryCode: string | null;
+            latitude: number | null;
+            longitude: number | null;
+            sortOrder: number;
+        }[];
         coverMedia: {
             id: string;
             mediaType: "image" | "video" | "document";
@@ -230,9 +332,15 @@ export declare const publicProductsService: {
             altText: string | null;
             sortOrder: number;
             isCover: boolean;
+            isBrochure: boolean;
+            isBrochureCurrent: boolean;
+            brochureVersion: number | null;
         } | null;
         isFeatured: boolean;
     } | null>;
+    getCatalogProductBrochure(db: PostgresJsDatabase, productId: string, query?: {
+        languageTag?: string | null;
+    }): Promise<unknown>;
     listCatalogCategories(db: PostgresJsDatabase, query: PublicCatalogCategoryListQuery): Promise<{
         data: {
             parentId: string | null;
@@ -255,5 +363,21 @@ export declare const publicProductsService: {
         limit: number;
         offset: number;
     }>;
+    listCatalogDestinations(db: PostgresJsDatabase, query: PublicCatalogDestinationListQuery): Promise<{
+        data: {
+            id: string;
+            parentId: string | null;
+            slug: string;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            destinationType: string;
+            sortOrder: number;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
 };
 //# sourceMappingURL=service-public.d.ts.map

package/dist/service-public.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-public.d.ts","sourceRoot":"","sources":["../src/service-public.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAiBjE,OAAO,KAAK,EACV,8BAA8B,EAC9B,6BAA6B,EAC7B,qCAAqC,EACrC,yBAAyB,EAC1B,MAAM,wBAAwB,CAAA;AAiY/B,eAAO,MAAM,qBAAqB;4BACF,kBAAkB,SAAS,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA8EhF,kBAAkB,MAClB,MAAM,UACH;QAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA2BlC,kBAAkB,QAChB,MAAM,UACL,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAmCd,kBAAkB,SAAS,8BAA8B;;;;;;;;;;;;;wBAkD/D,kBAAkB,SAAS,yBAAyB;;;;;;;;;CA8B/E,CAAA"}
+{"version":3,"file":"service-public.d.ts","sourceRoot":"","sources":["../src/service-public.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAgBjE,OAAO,KAAK,EACV,8BAA8B,EAC9B,iCAAiC,EACjC,6BAA6B,EAC7B,qCAAqC,EACrC,yBAAyB,EAC1B,MAAM,wBAAwB,CAAA;AAgI/B,eAAO,MAAM,qBAAqB;4BACF,kBAAkB,SAAS,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BA2HhF,kBAAkB,MAClB,MAAM,UACH;QAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA2BlC,kBAAkB,QAChB,MAAM,UACL,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAoCxC,kBAAkB,aACX,MAAM,UACV;QAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;8BAMR,kBAAkB,SAAS,8BAA8B;;;;;;;;;;;;;wBAkD/D,kBAAkB,SAAS,yBAAyB;;;;;;;;;gCA+B5C,kBAAkB,SAAS,iCAAiC;;;;;;;;;;;;;;;;CA8F/F,CAAA"}

package/dist/service-public.js

@@ -1,14 +1,9 @@
 import { and, asc, desc, eq, ilike, inArray, notInArray, or, sql } from "drizzle-orm";
-import { productCapabilities, productCategories, productCategoryProducts, productFaqs, productFeatures, productLocations, productMedia, products, productTagProducts, productTags, productTranslations, productTypes, productVisibilitySettings, } from "./schema.js";
+import { destinations, destinationTranslations, productCategories, productCategoryProducts, productDestinations, productLocations, products, productTagProducts, productTags, productTranslations, productVisibilitySettings, } from "./schema.js";
+import { catalogProductsService } from "./service-catalog.js";
 function impossibleCondition() {
     return sql `1 = 0`;
 }
-function normalizeDate(value) {
-    if (!value) {
-        return null;
-    }
-    return value instanceof Date ? value.toISOString() : value;
-}
 function normalizeLanguageTag(value) {
     const normalized = value?.trim().toLowerCase();
     return normalized || null;
@@ -28,6 +23,21 @@ async function listProductIdsForTag(db, tagId) {
         .where(eq(productTagProducts.tagId, tagId));
     return rows.map((row) => row.productId);
 }
+async function listProductIdsForDestinationId(db, destinationId) {
+    const rows = await db
+        .select({ productId: productDestinations.productId })
+        .from(productDestinations)
+        .where(eq(productDestinations.destinationId, destinationId));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForDestinationSlug(db, slug) {
+    const rows = await db
+        .select({ productId: productDestinations.productId })
+        .from(productDestinations)
+        .innerJoin(destinations, eq(destinations.id, productDestinations.destinationId))
+        .where(eq(destinations.slug, slug));
+    return rows.map((row) => row.productId);
+}
 async function listFeaturedProductIds(db) {
     const rows = await db
         .select({ productId: productVisibilitySettings.productId })
@@ -35,260 +45,39 @@ async function listFeaturedProductIds(db) {
         .where(eq(productVisibilitySettings.isFeatured, true));
     return rows.map((row) => row.productId);
 }
+async function listProductIdsForLocationTitle(db, title) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(ilike(productLocations.title, title));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForLocationCity(db, city) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(ilike(productLocations.city, city));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForLocationCountryCode(db, countryCode) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(eq(productLocations.countryCode, countryCode));
+    return rows.map((row) => row.productId);
+}
+async function listProductIdsForLocationType(db, locationType) {
+    const rows = await db
+        .select({ productId: productLocations.productId })
+        .from(productLocations)
+        .where(eq(productLocations.locationType, locationType));
+    return rows.map((row) => row.productId);
+}
 async function hydrateCatalogProducts(db, productRows, options) {
-    if (productRows.length === 0) {
-        return [];
-    }
-    const productIds = productRows.map((product) => product.id);
-    const productTypeIds = Array.from(new Set(productRows
-        .map((product) => product.productTypeId)
-        .filter((value) => Boolean(value))));
-    const [categoryRows, tagRows, translationRows, typeRows, capabilityRows, mediaRows, featuredRows, featureRows, faqRows, locationRows,] = await Promise.all([
-        db
-            .select({
-            productId: productCategoryProducts.productId,
-            id: productCategories.id,
-            parentId: productCategories.parentId,
-            name: productCategories.name,
-            slug: productCategories.slug,
-            description: productCategories.description,
-            sortOrder: productCategories.sortOrder,
-        })
-            .from(productCategoryProducts)
-            .innerJoin(productCategories, eq(productCategories.id, productCategoryProducts.categoryId))
-            .where(and(inArray(productCategoryProducts.productId, productIds), eq(productCategories.active, true)))
-            .orderBy(asc(productCategoryProducts.sortOrder), asc(productCategories.sortOrder), asc(productCategories.name)),
-        db
-            .select({
-            productId: productTagProducts.productId,
-            id: productTags.id,
-            name: productTags.name,
-        })
-            .from(productTagProducts)
-            .innerJoin(productTags, eq(productTags.id, productTagProducts.tagId))
-            .where(inArray(productTagProducts.productId, productIds))
-            .orderBy(asc(productTags.name)),
-        options?.languageTag
-            ? db
-                .select({
-                productId: productTranslations.productId,
-                languageTag: productTranslations.languageTag,
-                slug: productTranslations.slug,
-                name: productTranslations.name,
-                shortDescription: productTranslations.shortDescription,
-                description: productTranslations.description,
-                seoTitle: productTranslations.seoTitle,
-                seoDescription: productTranslations.seoDescription,
-            })
-                .from(productTranslations)
-                .where(and(inArray(productTranslations.productId, productIds), eq(productTranslations.languageTag, options.languageTag)))
-            : Promise.resolve([]),
-        productTypeIds.length > 0
-            ? db
-                .select({
-                id: productTypes.id,
-                code: productTypes.code,
-                name: productTypes.name,
-                description: productTypes.description,
-            })
-                .from(productTypes)
-                .where(and(inArray(productTypes.id, productTypeIds), eq(productTypes.active, true)))
-            : Promise.resolve([]),
-        db
-            .select({
-            productId: productCapabilities.productId,
-            capability: productCapabilities.capability,
-        })
-            .from(productCapabilities)
-            .where(and(inArray(productCapabilities.productId, productIds), eq(productCapabilities.enabled, true)))
-            .orderBy(asc(productCapabilities.capability)),
-        db
-            .select({
-            productId: productMedia.productId,
-            id: productMedia.id,
-            mediaType: productMedia.mediaType,
-            name: productMedia.name,
-            url: productMedia.url,
-            mimeType: productMedia.mimeType,
-            altText: productMedia.altText,
-            sortOrder: productMedia.sortOrder,
-            isCover: productMedia.isCover,
-        })
-            .from(productMedia)
-            .where(inArray(productMedia.productId, productIds))
-            .orderBy(desc(productMedia.isCover), asc(productMedia.sortOrder), asc(productMedia.createdAt)),
-        db
-            .select({ productId: productVisibilitySettings.productId })
-            .from(productVisibilitySettings)
-            .where(and(inArray(productVisibilitySettings.productId, productIds), eq(productVisibilitySettings.isFeatured, true))),
-        options?.includeContent
-            ? db
-                .select({
-                productId: productFeatures.productId,
-                id: productFeatures.id,
-                featureType: productFeatures.featureType,
-                title: productFeatures.title,
-                description: productFeatures.description,
-                sortOrder: productFeatures.sortOrder,
-            })
-                .from(productFeatures)
-                .where(inArray(productFeatures.productId, productIds))
-                .orderBy(asc(productFeatures.sortOrder), asc(productFeatures.createdAt))
-            : Promise.resolve([]),
-        options?.includeContent
-            ? db
-                .select({
-                productId: productFaqs.productId,
-                id: productFaqs.id,
-                question: productFaqs.question,
-                answer: productFaqs.answer,
-                sortOrder: productFaqs.sortOrder,
-            })
-                .from(productFaqs)
-                .where(inArray(productFaqs.productId, productIds))
-                .orderBy(asc(productFaqs.sortOrder), asc(productFaqs.createdAt))
-            : Promise.resolve([]),
-        options?.includeContent
-            ? db
-                .select({
-                productId: productLocations.productId,
-                id: productLocations.id,
-                locationType: productLocations.locationType,
-                title: productLocations.title,
-                address: productLocations.address,
-                city: productLocations.city,
-                countryCode: productLocations.countryCode,
-                latitude: productLocations.latitude,
-                longitude: productLocations.longitude,
-                sortOrder: productLocations.sortOrder,
-            })
-                .from(productLocations)
-                .where(inArray(productLocations.productId, productIds))
-                .orderBy(asc(productLocations.sortOrder), asc(productLocations.createdAt))
-            : Promise.resolve([]),
-    ]);
-    const categoriesByProduct = new Map();
-    for (const row of categoryRows) {
-        const existing = categoriesByProduct.get(row.productId) ?? [];
-        existing.push(row);
-        categoriesByProduct.set(row.productId, existing);
-    }
-    const tagsByProduct = new Map();
-    for (const row of tagRows) {
-        const existing = tagsByProduct.get(row.productId) ?? [];
-        existing.push(row);
-        tagsByProduct.set(row.productId, existing);
-    }
-    const translationByProduct = new Map(translationRows.map((row) => [row.productId, row]));
-    const capabilitiesByProduct = new Map();
-    for (const row of capabilityRows) {
-        const existing = capabilitiesByProduct.get(row.productId) ?? [];
-        existing.push(row.capability);
-        capabilitiesByProduct.set(row.productId, existing);
-    }
-    const mediaByProduct = new Map();
-    for (const row of mediaRows) {
-        const existing = mediaByProduct.get(row.productId) ?? [];
-        existing.push(row);
-        mediaByProduct.set(row.productId, existing);
-    }
-    const featuresByProduct = new Map();
-    for (const row of featureRows) {
-        const existing = featuresByProduct.get(row.productId) ?? [];
-        existing.push(row);
-        featuresByProduct.set(row.productId, existing);
-    }
-    const faqsByProduct = new Map();
-    for (const row of faqRows) {
-        const existing = faqsByProduct.get(row.productId) ?? [];
-        existing.push(row);
-        faqsByProduct.set(row.productId, existing);
-    }
-    const locationsByProduct = new Map();
-    for (const row of locationRows) {
-        const existing = locationsByProduct.get(row.productId) ?? [];
-        existing.push(row);
-        locationsByProduct.set(row.productId, existing);
-    }
-    const typeById = new Map(typeRows.map((row) => [row.id, row]));
-    const featuredIds = new Set(featuredRows.map((row) => row.productId));
-    return productRows.map((product) => {
-        const translation = translationByProduct.get(product.id) ?? null;
-        const media = (mediaByProduct.get(product.id) ?? []).map((row) => ({
-            id: row.id,
-            mediaType: row.mediaType,
-            name: row.name,
-            url: row.url,
-            mimeType: row.mimeType ?? null,
-            altText: row.altText ?? null,
-            sortOrder: row.sortOrder,
-            isCover: row.isCover,
-        }));
-        const base = {
-            id: product.id,
-            name: translation?.name ?? product.name,
-            description: translation?.description ?? product.description ?? null,
-            contentLanguageTag: translation?.languageTag ?? null,
-            slug: translation?.slug ?? null,
-            shortDescription: translation?.shortDescription ?? null,
-            seoTitle: translation?.seoTitle ?? null,
-            seoDescription: translation?.seoDescription ?? null,
-            bookingMode: product.bookingMode,
-            capacityMode: product.capacityMode,
-            visibility: product.visibility,
-            sellCurrency: product.sellCurrency,
-            sellAmountCents: product.sellAmountCents ?? null,
-            startDate: normalizeDate(product.startDate),
-            endDate: normalizeDate(product.endDate),
-            pax: product.pax ?? null,
-            productType: product.productTypeId ? (typeById.get(product.productTypeId) ?? null) : null,
-            categories: (categoriesByProduct.get(product.id) ?? []).map((row) => ({
-                id: row.id,
-                parentId: row.parentId ?? null,
-                name: row.name,
-                slug: row.slug,
-                description: row.description ?? null,
-                sortOrder: row.sortOrder,
-            })),
-            tags: (tagsByProduct.get(product.id) ?? []).map((row) => ({
-                id: row.id,
-                name: row.name,
-            })),
-            capabilities: capabilitiesByProduct.get(product.id) ?? [],
-            coverMedia: media.find((item) => item.isCover) ?? media[0] ?? null,
-            isFeatured: featuredIds.has(product.id),
-        };
-        if (!options?.includeContent) {
-            return base;
-        }
-        return {
-            ...base,
-            media,
-            features: (featuresByProduct.get(product.id) ?? []).map((row) => ({
-                id: row.id,
-                featureType: row.featureType,
-                title: row.title,
-                description: row.description ?? null,
-                sortOrder: row.sortOrder,
-            })),
-            faqs: (faqsByProduct.get(product.id) ?? []).map((row) => ({
-                id: row.id,
-                question: row.question,
-                answer: row.answer,
-                sortOrder: row.sortOrder,
-            })),
-            locations: (locationsByProduct.get(product.id) ?? []).map((row) => ({
-                id: row.id,
-                locationType: row.locationType,
-                title: row.title,
-                address: row.address ?? null,
-                city: row.city ?? null,
-                countryCode: row.countryCode ?? null,
-                latitude: row.latitude ?? null,
-                longitude: row.longitude ?? null,
-                sortOrder: row.sortOrder,
-            })),
-        };
+    return catalogProductsService.hydrateProducts(db, productRows, {
+        includeContent: options?.includeContent,
+        languageTag: options?.languageTag,
+        fallbackLanguageTags: options?.languageTag ? [options.languageTag] : [],
     });
 }
 function orderProducts(query) {
@@ -335,6 +124,14 @@ export const publicProductsService = {
             const productIds = await listProductIdsForTag(db, query.tagId);
             conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
         }
+        if (query.destinationId) {
+            const productIds = await listProductIdsForDestinationId(db, query.destinationId);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.destinationSlug) {
+            const productIds = await listProductIdsForDestinationSlug(db, query.destinationSlug);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
         if (query.featured !== undefined) {
             const productIds = await listFeaturedProductIds(db);
             conditions.push(query.featured
@@ -345,6 +142,22 @@ export const publicProductsService = {
                     ? notInArray(products.id, productIds)
                     : sql `1 = 1`);
         }
+        if (query.locationTitle) {
+            const productIds = await listProductIdsForLocationTitle(db, query.locationTitle);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.locationCity) {
+            const productIds = await listProductIdsForLocationCity(db, query.locationCity);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.locationCountryCode) {
+            const productIds = await listProductIdsForLocationCountryCode(db, query.locationCountryCode.toUpperCase());
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
+        if (query.locationType) {
+            const productIds = await listProductIdsForLocationType(db, query.locationType);
+            conditions.push(productIds.length > 0 ? inArray(products.id, productIds) : impossibleCondition());
+        }
         const where = and(...conditions);
         const [rows, countResult] = await Promise.all([
             db
@@ -409,6 +222,10 @@ export const publicProductsService = {
             languageTag: normalizedLanguageTag ?? row.languageTag,
         });
     },
+    async getCatalogProductBrochure(db, productId, query = {}) {
+        const product = await this.getCatalogProductById(db, productId, query);
+        return product && "brochure" in product ? product.brochure : null;
+    },
     async listCatalogCategories(db, query) {
         const conditions = [eq(productCategories.active, true)];
         if (query.parentId) {
@@ -476,4 +293,73 @@ export const publicProductsService = {
             offset: query.offset,
         };
     },
+    async listCatalogDestinations(db, query) {
+        const conditions = [];
+        if (query.parentId) {
+            conditions.push(eq(destinations.parentId, query.parentId));
+        }
+        if (query.active !== undefined) {
+            conditions.push(eq(destinations.active, query.active));
+        }
+        if (query.destinationType) {
+            conditions.push(eq(destinations.destinationType, query.destinationType));
+        }
+        if (query.search) {
+            const translationRows = await db
+                .select({ destinationId: destinationTranslations.destinationId })
+                .from(destinationTranslations)
+                .where(and(...(query.languageTag
+                ? [eq(destinationTranslations.languageTag, query.languageTag)]
+                : []), or(ilike(destinationTranslations.name, `%${query.search}%`), ilike(destinationTranslations.description, `%${query.search}%`))));
+            const destinationIds = translationRows.map((row) => row.destinationId);
+            conditions.push(destinationIds.length > 0
+                ? inArray(destinations.id, destinationIds)
+                : impossibleCondition());
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(destinations)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(destinations.sortOrder), asc(destinations.slug)),
+            db.select({ count: sql `count(*)::int` }).from(destinations).where(where),
+        ]);
+        const destinationIds = rows.map((row) => row.id);
+        const translations = destinationIds.length > 0
+            ? await db
+                .select()
+                .from(destinationTranslations)
+                .where(and(inArray(destinationTranslations.destinationId, destinationIds), ...(query.languageTag
+                ? [eq(destinationTranslations.languageTag, query.languageTag)]
+                : [])))
+            : [];
+        const translationByDestination = new Map();
+        for (const row of translations) {
+            if (!translationByDestination.has(row.destinationId)) {
+                translationByDestination.set(row.destinationId, row);
+            }
+        }
+        return {
+            data: rows.map((row) => {
+                const translation = translationByDestination.get(row.id);
+                return {
+                    id: row.id,
+                    parentId: row.parentId ?? null,
+                    slug: row.slug,
+                    name: translation?.name ?? row.slug,
+                    description: translation?.description ?? null,
+                    seoTitle: translation?.seoTitle ?? null,
+                    seoDescription: translation?.seoDescription ?? null,
+                    destinationType: row.destinationType,
+                    sortOrder: row.sortOrder,
+                };
+            }),
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
 };