@voyant-travel/inventory 0.1.0

package/dist/service-destinations.d.ts

@@ -0,0 +1,223 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import type { destinationListQuerySchema, destinationTranslationListQuerySchema, insertDestinationSchema, insertDestinationTranslationSchema, insertProductCategoryTranslationSchema, insertProductTagTranslationSchema, productCategoryTranslationListQuerySchema, productTagTranslationListQuerySchema, updateDestinationSchema, updateDestinationTranslationSchema, updateProductCategoryTranslationSchema, updateProductTagTranslationSchema } from "./validation.js";
+type DestinationListQuery = z.infer<typeof destinationListQuerySchema>;
+type CreateDestinationInput = z.infer<typeof insertDestinationSchema>;
+type UpdateDestinationInput = z.infer<typeof updateDestinationSchema>;
+type DestinationTranslationListQuery = z.infer<typeof destinationTranslationListQuerySchema>;
+type CreateDestinationTranslationInput = z.infer<typeof insertDestinationTranslationSchema>;
+type UpdateDestinationTranslationInput = z.infer<typeof updateDestinationTranslationSchema>;
+type ProductCategoryTranslationListQuery = z.infer<typeof productCategoryTranslationListQuerySchema>;
+type CreateProductCategoryTranslationInput = z.infer<typeof insertProductCategoryTranslationSchema>;
+type UpdateProductCategoryTranslationInput = z.infer<typeof updateProductCategoryTranslationSchema>;
+type ProductTagTranslationListQuery = z.infer<typeof productTagTranslationListQuerySchema>;
+type CreateProductTagTranslationInput = z.infer<typeof insertProductTagTranslationSchema>;
+type UpdateProductTagTranslationInput = z.infer<typeof updateProductTagTranslationSchema>;
+export declare const destinationProductsService: {
+    listDestinations(db: PostgresJsDatabase, query: DestinationListQuery): Promise<{
+        data: {
+            translation: {
+                id: string;
+                destinationId: string;
+                languageTag: string;
+                name: string;
+                description: string | null;
+                seoTitle: string | null;
+                seoDescription: string | null;
+                createdAt: Date;
+                updatedAt: Date;
+            } | null;
+            id: string;
+            parentId: string | null;
+            slug: string;
+            code: string | null;
+            canonicalPlaceId: string | null;
+            destinationType: string;
+            latitude: number | null;
+            longitude: number | null;
+            sortOrder: number;
+            active: boolean;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getDestinationById(db: PostgresJsDatabase, id: string): Promise<{
+        translations: {
+            id: string;
+            destinationId: string;
+            languageTag: string;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        id: string;
+        parentId: string | null;
+        slug: string;
+        code: string | null;
+        canonicalPlaceId: string | null;
+        destinationType: string;
+        latitude: number | null;
+        longitude: number | null;
+        sortOrder: number;
+        active: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createDestination(db: PostgresJsDatabase, data: CreateDestinationInput): Promise<{
+        id: string;
+        active: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        code: string | null;
+        sortOrder: number;
+        latitude: number | null;
+        longitude: number | null;
+        parentId: string | null;
+        destinationType: string;
+        canonicalPlaceId: string | null;
+        slug: string;
+    } | null>;
+    updateDestination(db: PostgresJsDatabase, id: string, data: UpdateDestinationInput): Promise<{
+        id: string;
+        parentId: string | null;
+        slug: string;
+        code: string | null;
+        canonicalPlaceId: string | null;
+        destinationType: string;
+        latitude: number | null;
+        longitude: number | null;
+        sortOrder: number;
+        active: boolean;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteDestination(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listDestinationTranslations(db: PostgresJsDatabase, query: DestinationTranslationListQuery): Promise<{
+        data: {
+            id: string;
+            destinationId: string;
+            languageTag: string;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    upsertDestinationTranslation(db: PostgresJsDatabase, destinationId: string, data: CreateDestinationTranslationInput): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        languageTag: string;
+        destinationId: string;
+        seoTitle: string | null;
+        seoDescription: string | null;
+    } | null>;
+    updateDestinationTranslation(db: PostgresJsDatabase, id: string, data: UpdateDestinationTranslationInput): Promise<{
+        id: string;
+        destinationId: string;
+        languageTag: string;
+        name: string;
+        description: string | null;
+        seoTitle: string | null;
+        seoDescription: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteDestinationTranslation(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listProductCategoryTranslations(db: PostgresJsDatabase, query: ProductCategoryTranslationListQuery): Promise<{
+        data: {
+            id: string;
+            categoryId: string;
+            languageTag: string;
+            name: string;
+            description: string | null;
+            seoTitle: string | null;
+            seoDescription: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    upsertProductCategoryTranslation(db: PostgresJsDatabase, categoryId: string, data: CreateProductCategoryTranslationInput): Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        categoryId: string;
+        languageTag: string;
+        seoTitle: string | null;
+        seoDescription: string | null;
+    } | null>;
+    updateProductCategoryTranslation(db: PostgresJsDatabase, id: string, data: UpdateProductCategoryTranslationInput): Promise<{
+        id: string;
+        categoryId: string;
+        languageTag: string;
+        name: string;
+        description: string | null;
+        seoTitle: string | null;
+        seoDescription: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProductCategoryTranslation(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listProductTagTranslations(db: PostgresJsDatabase, query: ProductTagTranslationListQuery): Promise<{
+        data: {
+            id: string;
+            tagId: string;
+            languageTag: string;
+            name: string;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    upsertProductTagTranslation(db: PostgresJsDatabase, tagId: string, data: CreateProductTagTranslationInput): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        languageTag: string;
+        tagId: string;
+    } | null>;
+    updateProductTagTranslation(db: PostgresJsDatabase, id: string, data: UpdateProductTagTranslationInput): Promise<{
+        id: string;
+        tagId: string;
+        languageTag: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteProductTagTranslation(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export {};
+//# sourceMappingURL=service-destinations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-destinations.d.ts","sourceRoot":"","sources":["../src/service-destinations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAS5B,OAAO,KAAK,EACV,0BAA0B,EAC1B,qCAAqC,EACrC,uBAAuB,EACvB,kCAAkC,EAClC,sCAAsC,EACtC,iCAAiC,EACjC,yCAAyC,EACzC,oCAAoC,EACpC,uBAAuB,EACvB,kCAAkC,EAClC,sCAAsC,EACtC,iCAAiC,EAClC,MAAM,iBAAiB,CAAA;AAExB,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AACtE,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACrE,KAAK,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACrE,KAAK,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AAC5F,KAAK,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC3F,KAAK,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC3F,KAAK,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yCAAyC,CAAC,CAAA;AACpG,KAAK,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAA;AACnG,KAAK,qCAAqC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAA;AACnG,KAAK,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAC1F,KAAK,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AACzF,KAAK,gCAAgC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAEzF,eAAO,MAAM,0BAA0B;yBACV,kBAAkB,SAAS,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA6F7C,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;0BAkB/B,kBAAkB,QAAQ,sBAAsB;;;;;;;;;;;;;;;0BAKhD,kBAAkB,MAAM,MAAM,QAAQ,sBAAsB;;;;;;;;;;;;;;;0BAU5D,kBAAkB,MAAM,MAAM;;;oCAUpD,kBAAkB,SACf,+BAA+B;;;;;;;;;;;;;;;;qCAkClC,kBAAkB,iBACP,MAAM,QACf,iCAAiC;;;;;;;;;;;qCAwCnC,kBAAkB,MAClB,MAAM,QACJ,iCAAiC;;;;;;;;;;;qCAWF,kBAAkB,MAAM,MAAM;;;wCAU/D,kBAAkB,SACf,mCAAmC;;;;;;;;;;;;;;;;yCAwCtC,kBAAkB,cACV,MAAM,QACZ,qCAAqC;;;;;;;;;;;yCAwCvC,kBAAkB,MAClB,MAAM,QACJ,qCAAqC;;;;;;;;;;;yCAWF,kBAAkB,MAAM,MAAM;;;mCASpC,kBAAkB,SAAS,8BAA8B;;;;;;;;;;;;;oCAiCxF,kBAAkB,SACf,MAAM,QACP,gCAAgC;;;;;;;;oCAwClC,kBAAkB,MAClB,MAAM,QACJ,gCAAgC;;;;;;;;oCAWF,kBAAkB,MAAM,MAAM;;;CAQrE,CAAA"}

package/dist/service-destinations.js

@@ -0,0 +1,310 @@
+import { and, asc, eq, ilike, inArray, or, sql } from "drizzle-orm";
+import { destinations, destinationTranslations, productCategories, productCategoryTranslations, productTags, productTagTranslations, } from "./schema.js";
+export const destinationProductsService = {
+    async listDestinations(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.canonicalPlaceId) {
+            conditions.push(eq(destinations.canonicalPlaceId, query.canonicalPlaceId));
+        }
+        if (query.search) {
+            const term = `%${query.search}%`;
+            const translationRows = await db
+                .select({ destinationId: destinationTranslations.destinationId })
+                .from(destinationTranslations)
+                .where(and(query.languageTag
+                ? eq(destinationTranslations.languageTag, query.languageTag)
+                : undefined, or(ilike(destinationTranslations.name, term), ilike(destinationTranslations.description, term))));
+            const destinationIds = translationRows.map((row) => row.destinationId);
+            conditions.push(destinationIds.length > 0 ? inArray(destinations.id, destinationIds) : sql `1 = 0`);
+        }
+        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)]
+                : [])))
+                .orderBy(asc(destinationTranslations.languageTag), asc(destinationTranslations.createdAt))
+            : [];
+        const translationsByDestination = new Map();
+        for (const row of translations) {
+            const existing = translationsByDestination.get(row.destinationId) ?? [];
+            existing.push(row);
+            translationsByDestination.set(row.destinationId, existing);
+        }
+        return {
+            data: rows.map((row) => ({
+                ...row,
+                translation: (translationsByDestination.get(row.id) ?? [])[0] ?? null,
+            })),
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async getDestinationById(db, id) {
+        const [row] = await db.select().from(destinations).where(eq(destinations.id, id)).limit(1);
+        if (!row) {
+            return null;
+        }
+        const translations = await db
+            .select()
+            .from(destinationTranslations)
+            .where(eq(destinationTranslations.destinationId, id))
+            .orderBy(asc(destinationTranslations.languageTag), asc(destinationTranslations.createdAt));
+        return {
+            ...row,
+            translations,
+        };
+    },
+    async createDestination(db, data) {
+        const [row] = await db.insert(destinations).values(data).returning();
+        return row ?? null;
+    },
+    async updateDestination(db, id, data) {
+        const [row] = await db
+            .update(destinations)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(destinations.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteDestination(db, id) {
+        const [row] = await db
+            .delete(destinations)
+            .where(eq(destinations.id, id))
+            .returning({ id: destinations.id });
+        return row ?? null;
+    },
+    async listDestinationTranslations(db, query) {
+        const conditions = [];
+        if (query.destinationId) {
+            conditions.push(eq(destinationTranslations.destinationId, query.destinationId));
+        }
+        if (query.languageTag) {
+            conditions.push(eq(destinationTranslations.languageTag, query.languageTag));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(destinationTranslations)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(destinationTranslations.languageTag), asc(destinationTranslations.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(destinationTranslations).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async upsertDestinationTranslation(db, destinationId, data) {
+        const [destination] = await db
+            .select({ id: destinations.id })
+            .from(destinations)
+            .where(eq(destinations.id, destinationId))
+            .limit(1);
+        if (!destination) {
+            return null;
+        }
+        const [existing] = await db
+            .select()
+            .from(destinationTranslations)
+            .where(and(eq(destinationTranslations.destinationId, destinationId), eq(destinationTranslations.languageTag, data.languageTag)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(destinationTranslations)
+                .set({ ...data, updatedAt: new Date() })
+                .where(eq(destinationTranslations.id, existing.id))
+                .returning();
+            return row ?? null;
+        }
+        const [row] = await db
+            .insert(destinationTranslations)
+            .values({ destinationId, ...data })
+            .returning();
+        return row ?? null;
+    },
+    async updateDestinationTranslation(db, id, data) {
+        const [row] = await db
+            .update(destinationTranslations)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(destinationTranslations.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteDestinationTranslation(db, id) {
+        const [row] = await db
+            .delete(destinationTranslations)
+            .where(eq(destinationTranslations.id, id))
+            .returning({ id: destinationTranslations.id });
+        return row ?? null;
+    },
+    async listProductCategoryTranslations(db, query) {
+        const conditions = [];
+        if (query.categoryId) {
+            conditions.push(eq(productCategoryTranslations.categoryId, query.categoryId));
+        }
+        if (query.languageTag) {
+            conditions.push(eq(productCategoryTranslations.languageTag, query.languageTag));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productCategoryTranslations)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(productCategoryTranslations.languageTag), asc(productCategoryTranslations.createdAt)),
+            db
+                .select({ count: sql `count(*)::int` })
+                .from(productCategoryTranslations)
+                .where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async upsertProductCategoryTranslation(db, categoryId, data) {
+        const [category] = await db
+            .select({ id: productCategories.id })
+            .from(productCategories)
+            .where(eq(productCategories.id, categoryId))
+            .limit(1);
+        if (!category) {
+            return null;
+        }
+        const [existing] = await db
+            .select()
+            .from(productCategoryTranslations)
+            .where(and(eq(productCategoryTranslations.categoryId, categoryId), eq(productCategoryTranslations.languageTag, data.languageTag)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(productCategoryTranslations)
+                .set({ ...data, updatedAt: new Date() })
+                .where(eq(productCategoryTranslations.id, existing.id))
+                .returning();
+            return row ?? null;
+        }
+        const [row] = await db
+            .insert(productCategoryTranslations)
+            .values({ categoryId, ...data })
+            .returning();
+        return row ?? null;
+    },
+    async updateProductCategoryTranslation(db, id, data) {
+        const [row] = await db
+            .update(productCategoryTranslations)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productCategoryTranslations.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteProductCategoryTranslation(db, id) {
+        const [row] = await db
+            .delete(productCategoryTranslations)
+            .where(eq(productCategoryTranslations.id, id))
+            .returning({ id: productCategoryTranslations.id });
+        return row ?? null;
+    },
+    async listProductTagTranslations(db, query) {
+        const conditions = [];
+        if (query.tagId) {
+            conditions.push(eq(productTagTranslations.tagId, query.tagId));
+        }
+        if (query.languageTag) {
+            conditions.push(eq(productTagTranslations.languageTag, query.languageTag));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        const [rows, countResult] = await Promise.all([
+            db
+                .select()
+                .from(productTagTranslations)
+                .where(where)
+                .limit(query.limit)
+                .offset(query.offset)
+                .orderBy(asc(productTagTranslations.languageTag), asc(productTagTranslations.createdAt)),
+            db.select({ count: sql `count(*)::int` }).from(productTagTranslations).where(where),
+        ]);
+        return {
+            data: rows,
+            total: countResult[0]?.count ?? 0,
+            limit: query.limit,
+            offset: query.offset,
+        };
+    },
+    async upsertProductTagTranslation(db, tagId, data) {
+        const [tag] = await db
+            .select({ id: productTags.id })
+            .from(productTags)
+            .where(eq(productTags.id, tagId))
+            .limit(1);
+        if (!tag) {
+            return null;
+        }
+        const [existing] = await db
+            .select()
+            .from(productTagTranslations)
+            .where(and(eq(productTagTranslations.tagId, tagId), eq(productTagTranslations.languageTag, data.languageTag)))
+            .limit(1);
+        if (existing) {
+            const [row] = await db
+                .update(productTagTranslations)
+                .set({ ...data, updatedAt: new Date() })
+                .where(eq(productTagTranslations.id, existing.id))
+                .returning();
+            return row ?? null;
+        }
+        const [row] = await db
+            .insert(productTagTranslations)
+            .values({ tagId, ...data })
+            .returning();
+        return row ?? null;
+    },
+    async updateProductTagTranslation(db, id, data) {
+        const [row] = await db
+            .update(productTagTranslations)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(productTagTranslations.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteProductTagTranslation(db, id) {
+        const [row] = await db
+            .delete(productTagTranslations)
+            .where(eq(productTagTranslations.id, id))
+            .returning({ id: productTagTranslations.id });
+        return row ?? null;
+    },
+};