@voyant-travel/inventory 0.1.0

package/dist/service-media.js

@@ -0,0 +1,320 @@
+import { and, asc, desc, eq, sql } from "drizzle-orm";
+import { productDays, productItineraries, productMedia, products } from "./schema.js";
+async function ensureProductExists(db, productId) {
+    const [product] = await db
+        .select({ id: products.id })
+        .from(products)
+        .where(eq(products.id, productId))
+        .limit(1);
+    return product ?? null;
+}
+async function getDayById(db, dayId) {
+    const [day] = await db
+        .select({
+        id: productDays.id,
+        itineraryId: productDays.itineraryId,
+        productId: productItineraries.productId,
+    })
+        .from(productDays)
+        .innerJoin(productItineraries, eq(productDays.itineraryId, productItineraries.id))
+        .where(eq(productDays.id, dayId))
+        .limit(1);
+    return day ?? null;
+}
+export const mediaProductsService = {
+    // ==========================================================================
+    // Product Media
+    // ==========================================================================
+    async listMedia(db, productId, query) {
+        const conditions = [eq(productMedia.productId, productId)];
+        if (query.dayId !== undefined) {
+            conditions.push(eq(productMedia.dayId, query.dayId));
+        }
+        if (query.mediaType) {
+            conditions.push(eq(productMedia.mediaType, query.mediaType));
+        }
+        if (query.isBrochure !== undefined) {
+            conditions.push(eq(productMedia.isBrochure, query.isBrochure));
+        }
+        if (query.isBrochureCurrent !== undefined) {
+            conditions.push(eq(productMedia.isBrochureCurrent, query.isBrochureCurrent));
+        }
+        const where = and(...conditions);
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productMedia)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(desc(productMedia.isCover), asc(productMedia.sortOrder), asc(productMedia.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productMedia).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async listProductLevelMedia(db, productId, query) {
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        const conditions = [eq(productMedia.productId, productId), sql `${productMedia.dayId} is null`];
+        if (query.mediaType) {
+            conditions.push(eq(productMedia.mediaType, query.mediaType));
+        }
+        if (query.isBrochure !== undefined) {
+            conditions.push(eq(productMedia.isBrochure, query.isBrochure));
+        }
+        if (query.isBrochureCurrent !== undefined) {
+            conditions.push(eq(productMedia.isBrochureCurrent, query.isBrochureCurrent));
+        }
+        const where = and(...conditions);
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productMedia)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(desc(productMedia.isCover), asc(productMedia.sortOrder), asc(productMedia.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productMedia).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getMediaById(db, id) {
+        const [row] = await db.select().from(productMedia).where(eq(productMedia.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createMedia(db, productId, data) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        if (data.dayId) {
+            if (data.isBrochure) {
+                return null;
+            }
+            const day = await getDayById(db, data.dayId);
+            if (!day || day.productId !== productId) {
+                return null;
+            }
+        }
+        if (data.isBrochure) {
+            await db
+                .update(productMedia)
+                .set({ isBrochureCurrent: false, updatedAt: new Date() })
+                .where(and(eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), 
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${productMedia.dayId} is null`));
+        }
+        const [row] = await db
+            .insert(productMedia)
+            .values({
+            productId,
+            dayId: data.dayId ?? null,
+            mediaType: data.mediaType,
+            name: data.name,
+            url: data.url,
+            storageKey: data.storageKey ?? null,
+            mimeType: data.mimeType ?? null,
+            fileSize: data.fileSize ?? null,
+            altText: data.altText ?? null,
+            sortOrder: data.sortOrder,
+            isCover: data.isCover,
+            isBrochure: data.isBrochure,
+            isBrochureCurrent: data.isBrochureCurrent,
+            brochureVersion: data.brochureVersion ?? null,
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateMedia(db, id, data) {
+        const existing = await mediaProductsService.getMediaById(db, id);
+        if (!existing) {
+            return null;
+        }
+        if (data.isBrochure === true && existing.dayId) {
+            return null;
+        }
+        if (data.isBrochure === true) {
+            await db
+                .update(productMedia)
+                .set({ isBrochureCurrent: false, updatedAt: new Date() })
+                .where(and(eq(productMedia.productId, existing.productId), eq(productMedia.isBrochure, true), 
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${productMedia.dayId} is null`, 
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${productMedia.id} <> ${id}`));
+        }
+        const [row] = await db
+            .update(productMedia)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productMedia.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMedia(db, id) {
+        const [row] = await db.delete(productMedia).where(eq(productMedia.id, id)).returning();
+        return row ?? null;
+    },
+    async setCoverMedia(db, productId, mediaId, dayId) {
+        // Unset existing cover in the same scope (product-level or day-level)
+        const scopeConditions = [eq(productMedia.productId, productId)];
+        if (dayId) {
+            scopeConditions.push(eq(productMedia.dayId, dayId));
+        }
+        else {
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            scopeConditions.push(sql `${productMedia.dayId} is null`);
+        }
+        await db
+            .update(productMedia)
+            .set({ isCover: false, updatedAt: new Date() })
+            .where(and(...scopeConditions));
+        const [row] = await db
+            .update(productMedia)
+            .set({ isCover: true, updatedAt: new Date() })
+            .where(eq(productMedia.id, mediaId))
+            .returning();
+        return row ?? null;
+    },
+    async reorderMedia(db, data) {
+        const results = await Promise.all(data.items.map(async (item) => {
+            const [row] = await db
+                .update(productMedia)
+                .set({ sortOrder: item.sortOrder, updatedAt: new Date() })
+                .where(eq(productMedia.id, item.id))
+                .returning({ id: productMedia.id });
+            return row;
+        }));
+        return results.filter((r) => r != null);
+    },
+    async getBrochure(db, productId) {
+        const [row] = await db
+            .select()
+            .from(productMedia)
+            .where(and(eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), eq(productMedia.isBrochureCurrent, true), 
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${productMedia.dayId} is null`))
+            .orderBy(desc(productMedia.brochureVersion), desc(productMedia.updatedAt), desc(productMedia.createdAt))
+            .limit(1);
+        return row ?? null;
+    },
+    async listBrochures(db, productId) {
+        return db
+            .select()
+            .from(productMedia)
+            .where(and(eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), 
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${productMedia.dayId} is null`))
+            .orderBy(desc(productMedia.isBrochureCurrent), desc(productMedia.brochureVersion), desc(productMedia.updatedAt), desc(productMedia.createdAt));
+    },
+    async upsertBrochure(db, productId, data) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        const brochures = await mediaProductsService.listBrochures(db, productId);
+        const nextVersion = brochures.reduce((maxVersion, brochure) => {
+            const version = brochure.brochureVersion ?? 0;
+            return version > maxVersion ? version : maxVersion;
+        }, 0) + 1;
+        return mediaProductsService.createMedia(db, productId, {
+            mediaType: "document",
+            dayId: null,
+            name: data.name,
+            url: data.url,
+            storageKey: data.storageKey ?? null,
+            mimeType: data.mimeType ?? "application/pdf",
+            fileSize: data.fileSize ?? null,
+            altText: data.altText ?? null,
+            sortOrder: data.sortOrder,
+            isCover: false,
+            isBrochure: true,
+            isBrochureCurrent: true,
+            brochureVersion: nextVersion,
+        });
+    },
+    async deleteBrochure(db, productId) {
+        const brochure = await mediaProductsService.getBrochure(db, productId);
+        if (!brochure) {
+            return null;
+        }
+        const [row] = await db.delete(productMedia).where(eq(productMedia.id, brochure.id)).returning();
+        const [previous] = await db
+            .select()
+            .from(productMedia)
+            .where(and(eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), 
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${productMedia.dayId} is null`))
+            .orderBy(desc(productMedia.brochureVersion), desc(productMedia.updatedAt), desc(productMedia.createdAt))
+            .limit(1);
+        if (previous) {
+            await db
+                .update(productMedia)
+                .set({ isBrochureCurrent: true, updatedAt: new Date() })
+                .where(eq(productMedia.id, previous.id));
+        }
+        return row ?? null;
+    },
+    async setCurrentBrochure(db, productId, brochureId) {
+        const [brochure] = await db
+            .select()
+            .from(productMedia)
+            .where(and(eq(productMedia.id, brochureId), eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), 
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${productMedia.dayId} is null`))
+            .limit(1);
+        if (!brochure) {
+            return null;
+        }
+        await db
+            .update(productMedia)
+            .set({ isBrochureCurrent: false, updatedAt: new Date() })
+            .where(and(eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), 
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${productMedia.dayId} is null`));
+        const [row] = await db
+            .update(productMedia)
+            .set({ isBrochureCurrent: true, updatedAt: new Date() })
+            .where(eq(productMedia.id, brochureId))
+            .returning();
+        return row ?? null;
+    },
+    async deleteBrochureVersion(db, productId, brochureId) {
+        const [brochure] = await db
+            .select()
+            .from(productMedia)
+            .where(and(eq(productMedia.id, brochureId), eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), 
+        // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        sql `${productMedia.dayId} is null`))
+            .limit(1);
+        if (!brochure) {
+            return null;
+        }
+        const [row] = await db.delete(productMedia).where(eq(productMedia.id, brochureId)).returning();
+        if (brochure.isBrochureCurrent) {
+            const [previous] = await db
+                .select()
+                .from(productMedia)
+                .where(and(eq(productMedia.productId, productId), eq(productMedia.isBrochure, true), 
+            // agent-quality: raw-sql reviewed -- owner: inventory; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            sql `${productMedia.dayId} is null`))
+                .orderBy(desc(productMedia.brochureVersion), desc(productMedia.updatedAt), desc(productMedia.createdAt))
+                .limit(1);
+            if (previous) {
+                await db
+                    .update(productMedia)
+                    .set({ isBrochureCurrent: true, updatedAt: new Date() })
+                    .where(eq(productMedia.id, previous.id));
+            }
+        }
+        return row ?? null;
+    },
+};

package/dist/service-merchandising.d.ts

@@ -0,0 +1,184 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { insertProductFaqSchema, insertProductFeatureSchema, insertProductLocationSchema, productFaqListQuerySchema, productFeatureListQuerySchema, productLocationListQuerySchema, updateProductFaqSchema, updateProductFeatureSchema, updateProductLocationSchema } from "./validation.js";
+type ProductFeatureListQuery = z.infer<typeof productFeatureListQuerySchema>;
+type CreateProductFeatureInput = z.infer<typeof insertProductFeatureSchema>;
+type UpdateProductFeatureInput = z.infer<typeof updateProductFeatureSchema>;
+type ProductFaqListQuery = z.infer<typeof productFaqListQuerySchema>;
+type CreateProductFaqInput = z.infer<typeof insertProductFaqSchema>;
+type UpdateProductFaqInput = z.infer<typeof updateProductFaqSchema>;
+type ProductLocationListQuery = z.infer<typeof productLocationListQuerySchema>;
+type CreateProductLocationInput = z.infer<typeof insertProductLocationSchema>;
+type UpdateProductLocationInput = z.infer<typeof updateProductLocationSchema>;
+export declare const merchandisingProductsService: {
+    listFeatures(db: PostgresJsDatabase, query: ProductFeatureListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            featureType: "other" | "inclusion" | "exclusion" | "highlight" | "important_information";
+            title: string;
+            description: string | null;
+            sortOrder: number;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getFeatureById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        productId: string;
+        featureType: "other" | "inclusion" | "exclusion" | "highlight" | "important_information";
+        title: string;
+        description: string | null;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createFeature(db: PostgresJsDatabase, productId: string, data: CreateProductFeatureInput): Promise<{
+        id: string;
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        productId: string;
+        featureType: "other" | "inclusion" | "exclusion" | "highlight" | "important_information";
+        sortOrder: number;
+    } | null>;
+    updateFeature(db: PostgresJsDatabase, id: string, data: UpdateProductFeatureInput): Promise<{
+        id: string;
+        productId: string;
+        featureType: "other" | "inclusion" | "exclusion" | "highlight" | "important_information";
+        title: string;
+        description: string | null;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteFeature(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listFaqs(db: PostgresJsDatabase, query: ProductFaqListQuery): Promise<{
+        data: {
+            id: string;
+            productId: string;
+            question: string;
+            answer: string;
+            sortOrder: number;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getFaqById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        productId: string;
+        question: string;
+        answer: string;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createFaq(db: PostgresJsDatabase, productId: string, data: CreateProductFaqInput): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        productId: string;
+        sortOrder: number;
+        question: string;
+        answer: string;
+    } | null>;
+    updateFaq(db: PostgresJsDatabase, id: string, data: UpdateProductFaqInput): Promise<{
+        id: string;
+        productId: string;
+        question: string;
+        answer: string;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteFaq(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listLocations(db: PostgresJsDatabase, query: ProductLocationListQuery): Promise<{
+        data: {
+            id: string;
+            productId: 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;
+            googlePlaceId: string | null;
+            applePlaceId: string | null;
+            tripadvisorLocationId: string | null;
+            sortOrder: number;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getLocationById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        productId: 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;
+        googlePlaceId: string | null;
+        applePlaceId: string | null;
+        tripadvisorLocationId: string | null;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createLocation(db: PostgresJsDatabase, productId: string, data: CreateProductLocationInput): Promise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title: string;
+        productId: string;
+        sortOrder: number;
+        locationType: "other" | "start" | "end" | "meeting_point" | "pickup" | "dropoff" | "point_of_interest";
+        address: string | null;
+        city: string | null;
+        countryCode: string | null;
+        latitude: number | null;
+        longitude: number | null;
+        googlePlaceId: string | null;
+        applePlaceId: string | null;
+        tripadvisorLocationId: string | null;
+    } | null>;
+    updateLocation(db: PostgresJsDatabase, id: string, data: UpdateProductLocationInput): Promise<{
+        id: string;
+        productId: 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;
+        googlePlaceId: string | null;
+        applePlaceId: string | null;
+        tripadvisorLocationId: string | null;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteLocation(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-merchandising.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-merchandising.d.ts","sourceRoot":"","sources":["../src/service-merchandising.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,2BAA2B,EAC3B,yBAAyB,EACzB,6BAA6B,EAC7B,8BAA8B,EAC9B,sBAAsB,EACtB,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,iBAAiB,CAAA;AAExB,KAAK,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAC5E,KAAK,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC3E,KAAK,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC3E,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACpE,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACnE,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACnE,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAC9E,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAC7E,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAY7E,eAAO,MAAM,4BAA4B;qBAChB,kBAAkB,SAAS,uBAAuB;;;;;;;;;;;;;;;uBAgChD,kBAAkB,MAAM,MAAM;;;;;;;;;;sBAK/B,kBAAkB,aAAa,MAAM,QAAQ,yBAAyB;;;;;;;;;;sBActE,kBAAkB,MAAM,MAAM,QAAQ,yBAAyB;;;;;;;;;;sBAU/D,kBAAkB,MAAM,MAAM;;;iBASnC,kBAAkB,SAAS,mBAAmB;;;;;;;;;;;;;;mBA4B5C,kBAAkB,MAAM,MAAM;;;;;;;;;kBAK/B,kBAAkB,aAAa,MAAM,QAAQ,qBAAqB;;;;;;;;;kBAclE,kBAAkB,MAAM,MAAM,QAAQ,qBAAqB;;;;;;;;;kBAU3D,kBAAkB,MAAM,MAAM;;;sBAS1B,kBAAkB,SAAS,wBAAwB;;;;;;;;;;;;;;;;;;;;;;wBAgCjD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;uBAUlD,kBAAkB,aACX,MAAM,QACX,0BAA0B;;;;;;;;;;;;;;;;;uBAeT,kBAAkB,MAAM,MAAM,QAAQ,0BAA0B;;;;;;;;;;;;;;;;;uBAUhE,kBAAkB,MAAM,MAAM;;;CAQxD,CAAA"}

package/dist/service-merchandising.js

@@ -0,0 +1,181 @@
+import { and, asc, eq, sql } from "drizzle-orm";
+import { productFaqs, productFeatures, productLocations, products } from "./schema.js";
+async function ensureProductExists(db, productId) {
+    const [product] = await db
+        .select({ id: products.id })
+        .from(products)
+        .where(eq(products.id, productId))
+        .limit(1);
+    return product ?? null;
+}
+export const merchandisingProductsService = {
+    async listFeatures(db, query) {
+        const conditions = [];
+        if (query.productId) {
+            conditions.push(eq(productFeatures.productId, query.productId));
+        }
+        if (query.featureType) {
+            conditions.push(eq(productFeatures.featureType, query.featureType));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productFeatures)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(productFeatures.sortOrder), asc(productFeatures.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productFeatures).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getFeatureById(db, id) {
+        const [row] = await db.select().from(productFeatures).where(eq(productFeatures.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createFeature(db, productId, data) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        const [row] = await db
+            .insert(productFeatures)
+            .values({ productId, ...data })
+            .returning();
+        return row ?? null;
+    },
+    async updateFeature(db, id, data) {
+        const [row] = await db
+            .update(productFeatures)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productFeatures.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteFeature(db, id) {
+        const [row] = await db
+            .delete(productFeatures)
+            .where(eq(productFeatures.id, id))
+            .returning({ id: productFeatures.id });
+        return row ?? null;
+    },
+    async listFaqs(db, query) {
+        const conditions = [];
+        if (query.productId) {
+            conditions.push(eq(productFaqs.productId, query.productId));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productFaqs)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(productFaqs.sortOrder), asc(productFaqs.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productFaqs).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getFaqById(db, id) {
+        const [row] = await db.select().from(productFaqs).where(eq(productFaqs.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createFaq(db, productId, data) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        const [row] = await db
+            .insert(productFaqs)
+            .values({ productId, ...data })
+            .returning();
+        return row ?? null;
+    },
+    async updateFaq(db, id, data) {
+        const [row] = await db
+            .update(productFaqs)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productFaqs.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteFaq(db, id) {
+        const [row] = await db
+            .delete(productFaqs)
+            .where(eq(productFaqs.id, id))
+            .returning({ id: productFaqs.id });
+        return row ?? null;
+    },
+    async listLocations(db, query) {
+        const conditions = [];
+        if (query.productId) {
+            conditions.push(eq(productLocations.productId, query.productId));
+        }
+        if (query.locationType) {
+            conditions.push(eq(productLocations.locationType, query.locationType));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productLocations)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(productLocations.sortOrder), asc(productLocations.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productLocations).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getLocationById(db, id) {
+        const [row] = await db
+            .select()
+            .from(productLocations)
+            .where(eq(productLocations.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createLocation(db, productId, data) {
+        const product = await ensureProductExists(db, productId);
+        if (!product) {
+            return null;
+        }
+        const [row] = await db
+            .insert(productLocations)
+            .values({ productId, ...data })
+            .returning();
+        return row ?? null;
+    },
+    async updateLocation(db, id, data) {
+        const [row] = await db
+            .update(productLocations)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productLocations.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteLocation(db, id) {
+        const [row] = await db
+            .delete(productLocations)
+            .where(eq(productLocations.id, id))
+            .returning({ id: productLocations.id });
+        return row ?? null;
+    },
+};