@voyantjs/markets 0.1.0

package/dist/service.js

@@ -0,0 +1,403 @@
+import { and, asc, desc, eq, ilike, or, sql } from "drizzle-orm";
+import { exchangeRates, fxRateSets, marketChannelRules, marketCurrencies, marketLocales, marketPriceCatalogs, marketProductRules, markets, } from "./schema.js";
+async function paginate(rowsQuery, countQuery, limit, offset) {
+    const [data, countResult] = await Promise.all([rowsQuery, countQuery]);
+    return { data, total: countResult[0]?.count ?? 0, limit, offset };
+}
+function toTimestamp(value) {
+    return value ? new Date(value) : null;
+}
+export const marketsService = {
+    async listMarkets(db, query) {
+        const conditions = [];
+        if (query.status)
+            conditions.push(eq(markets.status, query.status));
+        if (query.countryCode)
+            conditions.push(eq(markets.countryCode, query.countryCode));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(markets.name, term), ilike(markets.code, term)));
+        }
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(markets)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(markets.updatedAt)), db.select({ count: sql `count(*)::int` }).from(markets).where(where), query.limit, query.offset);
+    },
+    async getMarketById(db, id) {
+        const [row] = await db.select().from(markets).where(eq(markets.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createMarket(db, data) {
+        const [row] = await db.insert(markets).values(data).returning();
+        return row ?? null;
+    },
+    async updateMarket(db, id, data) {
+        const [row] = await db
+            .update(markets)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(markets.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMarket(db, id) {
+        const [row] = await db.delete(markets).where(eq(markets.id, id)).returning({ id: markets.id });
+        return row ?? null;
+    },
+    async listMarketLocales(db, query) {
+        const conditions = [];
+        if (query.marketId)
+            conditions.push(eq(marketLocales.marketId, query.marketId));
+        if (query.languageTag)
+            conditions.push(eq(marketLocales.languageTag, query.languageTag));
+        if (query.active !== undefined)
+            conditions.push(eq(marketLocales.active, query.active));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(marketLocales)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(marketLocales.sortOrder), asc(marketLocales.createdAt)), db.select({ count: sql `count(*)::int` }).from(marketLocales).where(where), query.limit, query.offset);
+    },
+    async createMarketLocale(db, marketId, data) {
+        const [market] = await db
+            .select({ id: markets.id })
+            .from(markets)
+            .where(eq(markets.id, marketId))
+            .limit(1);
+        if (!market)
+            return null;
+        const [row] = await db
+            .insert(marketLocales)
+            .values({ ...data, marketId })
+            .returning();
+        return row ?? null;
+    },
+    async updateMarketLocale(db, id, data) {
+        const [row] = await db
+            .update(marketLocales)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(marketLocales.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMarketLocale(db, id) {
+        const [row] = await db
+            .delete(marketLocales)
+            .where(eq(marketLocales.id, id))
+            .returning({ id: marketLocales.id });
+        return row ?? null;
+    },
+    async listMarketCurrencies(db, query) {
+        const conditions = [];
+        if (query.marketId)
+            conditions.push(eq(marketCurrencies.marketId, query.marketId));
+        if (query.currencyCode)
+            conditions.push(eq(marketCurrencies.currencyCode, query.currencyCode));
+        if (query.active !== undefined)
+            conditions.push(eq(marketCurrencies.active, query.active));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(marketCurrencies)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(marketCurrencies.sortOrder), asc(marketCurrencies.createdAt)), db.select({ count: sql `count(*)::int` }).from(marketCurrencies).where(where), query.limit, query.offset);
+    },
+    async createMarketCurrency(db, marketId, data) {
+        const [market] = await db
+            .select({ id: markets.id })
+            .from(markets)
+            .where(eq(markets.id, marketId))
+            .limit(1);
+        if (!market)
+            return null;
+        const [row] = await db
+            .insert(marketCurrencies)
+            .values({ ...data, marketId })
+            .returning();
+        return row ?? null;
+    },
+    async updateMarketCurrency(db, id, data) {
+        const [row] = await db
+            .update(marketCurrencies)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(marketCurrencies.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMarketCurrency(db, id) {
+        const [row] = await db
+            .delete(marketCurrencies)
+            .where(eq(marketCurrencies.id, id))
+            .returning({ id: marketCurrencies.id });
+        return row ?? null;
+    },
+    async listFxRateSets(db, query) {
+        const conditions = [];
+        if (query.source)
+            conditions.push(eq(fxRateSets.source, query.source));
+        if (query.baseCurrency)
+            conditions.push(eq(fxRateSets.baseCurrency, query.baseCurrency));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(fxRateSets)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(fxRateSets.effectiveAt)), db.select({ count: sql `count(*)::int` }).from(fxRateSets).where(where), query.limit, query.offset);
+    },
+    async getFxRateSetById(db, id) {
+        const [row] = await db.select().from(fxRateSets).where(eq(fxRateSets.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createFxRateSet(db, data) {
+        const [row] = await db
+            .insert(fxRateSets)
+            .values({
+            ...data,
+            effectiveAt: new Date(data.effectiveAt),
+            observedAt: toTimestamp(data.observedAt),
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateFxRateSet(db, id, data) {
+        const [row] = await db
+            .update(fxRateSets)
+            .set({
+            ...data,
+            effectiveAt: data.effectiveAt === undefined ? undefined : new Date(data.effectiveAt),
+            observedAt: data.observedAt === undefined ? undefined : toTimestamp(data.observedAt),
+        })
+            .where(eq(fxRateSets.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteFxRateSet(db, id) {
+        const [row] = await db
+            .delete(fxRateSets)
+            .where(eq(fxRateSets.id, id))
+            .returning({ id: fxRateSets.id });
+        return row ?? null;
+    },
+    async listExchangeRates(db, query) {
+        const conditions = [];
+        if (query.fxRateSetId)
+            conditions.push(eq(exchangeRates.fxRateSetId, query.fxRateSetId));
+        if (query.baseCurrency)
+            conditions.push(eq(exchangeRates.baseCurrency, query.baseCurrency));
+        if (query.quoteCurrency)
+            conditions.push(eq(exchangeRates.quoteCurrency, query.quoteCurrency));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(exchangeRates)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(asc(exchangeRates.quoteCurrency)), db.select({ count: sql `count(*)::int` }).from(exchangeRates).where(where), query.limit, query.offset);
+    },
+    async createExchangeRate(db, fxRateSetId, data) {
+        const [rateSet] = await db
+            .select({ id: fxRateSets.id })
+            .from(fxRateSets)
+            .where(eq(fxRateSets.id, fxRateSetId))
+            .limit(1);
+        if (!rateSet)
+            return null;
+        const [row] = await db
+            .insert(exchangeRates)
+            .values({
+            ...data,
+            fxRateSetId,
+            observedAt: toTimestamp(data.observedAt),
+        })
+            .returning();
+        return row ?? null;
+    },
+    async updateExchangeRate(db, id, data) {
+        const [row] = await db
+            .update(exchangeRates)
+            .set({
+            ...data,
+            observedAt: data.observedAt === undefined ? undefined : toTimestamp(data.observedAt),
+        })
+            .where(eq(exchangeRates.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteExchangeRate(db, id) {
+        const [row] = await db
+            .delete(exchangeRates)
+            .where(eq(exchangeRates.id, id))
+            .returning({ id: exchangeRates.id });
+        return row ?? null;
+    },
+    async listMarketPriceCatalogs(db, query) {
+        const conditions = [];
+        if (query.marketId)
+            conditions.push(eq(marketPriceCatalogs.marketId, query.marketId));
+        if (query.priceCatalogId)
+            conditions.push(eq(marketPriceCatalogs.priceCatalogId, query.priceCatalogId));
+        if (query.active !== undefined)
+            conditions.push(eq(marketPriceCatalogs.active, query.active));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(marketPriceCatalogs)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(marketPriceCatalogs.isDefault), desc(marketPriceCatalogs.priority)), db.select({ count: sql `count(*)::int` }).from(marketPriceCatalogs).where(where), query.limit, query.offset);
+    },
+    async getMarketPriceCatalogById(db, id) {
+        const [row] = await db
+            .select()
+            .from(marketPriceCatalogs)
+            .where(eq(marketPriceCatalogs.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createMarketPriceCatalog(db, data) {
+        const [market] = await db
+            .select({ id: markets.id })
+            .from(markets)
+            .where(eq(markets.id, data.marketId))
+            .limit(1);
+        if (!market)
+            return null;
+        const [row] = await db.insert(marketPriceCatalogs).values(data).returning();
+        return row ?? null;
+    },
+    async updateMarketPriceCatalog(db, id, data) {
+        const [row] = await db
+            .update(marketPriceCatalogs)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(marketPriceCatalogs.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMarketPriceCatalog(db, id) {
+        const [row] = await db
+            .delete(marketPriceCatalogs)
+            .where(eq(marketPriceCatalogs.id, id))
+            .returning({ id: marketPriceCatalogs.id });
+        return row ?? null;
+    },
+    async listMarketProductRules(db, query) {
+        const conditions = [];
+        if (query.marketId)
+            conditions.push(eq(marketProductRules.marketId, query.marketId));
+        if (query.productId)
+            conditions.push(eq(marketProductRules.productId, query.productId));
+        if (query.optionId)
+            conditions.push(eq(marketProductRules.optionId, query.optionId));
+        if (query.sellability)
+            conditions.push(eq(marketProductRules.sellability, query.sellability));
+        if (query.active !== undefined)
+            conditions.push(eq(marketProductRules.active, query.active));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(marketProductRules)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(marketProductRules.updatedAt)), db.select({ count: sql `count(*)::int` }).from(marketProductRules).where(where), query.limit, query.offset);
+    },
+    async getMarketProductRuleById(db, id) {
+        const [row] = await db
+            .select()
+            .from(marketProductRules)
+            .where(eq(marketProductRules.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createMarketProductRule(db, data) {
+        const [market] = await db
+            .select({ id: markets.id })
+            .from(markets)
+            .where(eq(markets.id, data.marketId))
+            .limit(1);
+        if (!market)
+            return null;
+        const [row] = await db.insert(marketProductRules).values(data).returning();
+        return row ?? null;
+    },
+    async updateMarketProductRule(db, id, data) {
+        const [row] = await db
+            .update(marketProductRules)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(marketProductRules.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMarketProductRule(db, id) {
+        const [row] = await db
+            .delete(marketProductRules)
+            .where(eq(marketProductRules.id, id))
+            .returning({ id: marketProductRules.id });
+        return row ?? null;
+    },
+    async listMarketChannelRules(db, query) {
+        const conditions = [];
+        if (query.marketId)
+            conditions.push(eq(marketChannelRules.marketId, query.marketId));
+        if (query.channelId)
+            conditions.push(eq(marketChannelRules.channelId, query.channelId));
+        if (query.sellability)
+            conditions.push(eq(marketChannelRules.sellability, query.sellability));
+        if (query.active !== undefined)
+            conditions.push(eq(marketChannelRules.active, query.active));
+        const where = conditions.length > 0 ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(marketChannelRules)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(marketChannelRules.priority), desc(marketChannelRules.updatedAt)), db.select({ count: sql `count(*)::int` }).from(marketChannelRules).where(where), query.limit, query.offset);
+    },
+    async getMarketChannelRuleById(db, id) {
+        const [row] = await db
+            .select()
+            .from(marketChannelRules)
+            .where(eq(marketChannelRules.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createMarketChannelRule(db, data) {
+        const [market] = await db
+            .select({ id: markets.id })
+            .from(markets)
+            .where(eq(markets.id, data.marketId))
+            .limit(1);
+        if (!market)
+            return null;
+        const [row] = await db.insert(marketChannelRules).values(data).returning();
+        return row ?? null;
+    },
+    async updateMarketChannelRule(db, id, data) {
+        const [row] = await db
+            .update(marketChannelRules)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(marketChannelRules.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteMarketChannelRule(db, id) {
+        const [row] = await db
+            .delete(marketChannelRules)
+            .where(eq(marketChannelRules.id, id))
+            .returning({ id: marketChannelRules.id });
+        return row ?? null;
+    },
+};