@86d-store/multi-currency 0.1.0

package/dist/index.js

@@ -0,0 +1,69 @@
+import { adminEndpoints } from "./admin/endpoints/routes";
+import { productPriceConversionProvider } from "./capabilities";
+import { multiCurrencyStorage } from "./schema";
+import { createMultiCurrencyController } from "./service-impl";
+import { storeEndpoints } from "./store/endpoints/routes";
+/**
+ * Multi-currency module factory.
+ * Provides currency management, exchange rate tracking, price conversion,
+ * and per-product price overrides for international commerce.
+ */
+export default function multiCurrency(options) {
+    return {
+        id: "multi-currency",
+        version: "0.0.1",
+        storage: multiCurrencyStorage,
+        capabilities: { provides: [productPriceConversionProvider] },
+        exports: {
+            read: [
+                "currencyCode",
+                "exchangeRate",
+                "formattedPrice",
+                "convertedAmount",
+            ],
+        },
+        events: {
+            emits: [
+                "currency.created",
+                "currency.updated",
+                "currency.deleted",
+                "currency.baseChanged",
+                "currency.rateUpdated",
+            ],
+        },
+        init: async (ctx) => {
+            const controller = createMultiCurrencyController(ctx.data, ctx.events);
+            return {
+                controllers: { multiCurrency: controller },
+            };
+        },
+        endpoints: {
+            store: storeEndpoints,
+            admin: adminEndpoints,
+        },
+        admin: {
+            pages: [
+                {
+                    path: "/admin/currencies",
+                    component: "CurrencyList",
+                    label: "Currencies",
+                    icon: "Coins",
+                    group: "Finance",
+                },
+                {
+                    path: "/admin/currencies/new",
+                    component: "CurrencyForm",
+                },
+                {
+                    path: "/admin/currencies/:id",
+                    component: "CurrencyDetail",
+                },
+                {
+                    path: "/admin/currencies/:id/edit",
+                    component: "CurrencyForm",
+                },
+            ],
+        },
+        options,
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+export declare const multiCurrencyCurrencyShape: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodString;
+    symbol: z.ZodString;
+    decimalPlaces: z.ZodDefault<z.ZodInt>;
+    exchangeRate: z.ZodDefault<z.ZodInt>;
+    isBase: z.ZodDefault<z.ZodBoolean>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    symbolPosition: z.ZodDefault<z.ZodEnum<{
+        before: "before";
+        after: "after";
+    }>>;
+    thousandsSeparator: z.ZodDefault<z.ZodString>;
+    decimalSeparator: z.ZodDefault<z.ZodString>;
+    roundingMode: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        ceil: "ceil";
+        floor: "floor";
+    }>>;
+    sortOrder: z.ZodDefault<z.ZodInt>;
+    createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const multiCurrencyExchangeRateHistoryShape: z.ZodObject<{
+    id: z.ZodString;
+    currencyCode: z.ZodString;
+    rate: z.ZodNumber;
+    source: z.ZodDefault<z.ZodString>;
+    recordedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const multiCurrencyPriceOverrideShape: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodString;
+    currencyCode: z.ZodString;
+    price: z.ZodNumber;
+    compareAtPrice: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+    updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+/** Native Relational storage for multi-currency. */
+export declare const multiCurrencyStorage: {
+    readonly kind: "relational";
+    readonly tables: {
+        readonly currency: {
+            readonly shape: z.ZodObject<{
+                id: z.ZodString;
+                code: z.ZodString;
+                name: z.ZodString;
+                symbol: z.ZodString;
+                decimalPlaces: z.ZodDefault<z.ZodInt>;
+                exchangeRate: z.ZodDefault<z.ZodInt>;
+                isBase: z.ZodDefault<z.ZodBoolean>;
+                isActive: z.ZodDefault<z.ZodBoolean>;
+                symbolPosition: z.ZodDefault<z.ZodEnum<{
+                    before: "before";
+                    after: "after";
+                }>>;
+                thousandsSeparator: z.ZodDefault<z.ZodString>;
+                decimalSeparator: z.ZodDefault<z.ZodString>;
+                roundingMode: z.ZodDefault<z.ZodEnum<{
+                    round: "round";
+                    ceil: "ceil";
+                    floor: "floor";
+                }>>;
+                sortOrder: z.ZodDefault<z.ZodInt>;
+                createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+                updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+            }, z.core.$strip>;
+        };
+        readonly exchangeRateHistory: {
+            readonly shape: z.ZodObject<{
+                id: z.ZodString;
+                currencyCode: z.ZodString;
+                rate: z.ZodNumber;
+                source: z.ZodDefault<z.ZodString>;
+                recordedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+            }, z.core.$strip>;
+        };
+        readonly priceOverride: {
+            readonly shape: z.ZodObject<{
+                id: z.ZodString;
+                productId: z.ZodString;
+                currencyCode: z.ZodString;
+                price: z.ZodNumber;
+                compareAtPrice: z.ZodOptional<z.ZodNumber>;
+                createdAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+                updatedAt: z.ZodDefault<z.ZodCoercedDate<unknown>>;
+            }, z.core.$strip>;
+        };
+    };
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;iBAgBrC,CAAC;AAEH,eAAO,MAAM,qCAAqC;;;;;;iBAMhD,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;iBAQ1C,CAAC;AAEH,oDAAoD;AACpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaY,CAAC"}

package/dist/schema.js

@@ -0,0 +1,50 @@
+import { col } from "@86d-store/core/schema/col";
+import { z } from "zod";
+export const multiCurrencyCurrencyShape = z.object({
+    id: z.string().register(col, { pk: true }),
+    code: z.string().register(col, { unique: true }),
+    name: z.string(),
+    symbol: z.string(),
+    decimalPlaces: z.int().default(2),
+    exchangeRate: z.int().default(1),
+    isBase: z.boolean().default(false),
+    isActive: z.boolean().default(true),
+    symbolPosition: z.enum(["before", "after"]).default("before"),
+    thousandsSeparator: z.string().default(","),
+    decimalSeparator: z.string().default("."),
+    roundingMode: z.enum(["round", "ceil", "floor"]).default("round"),
+    sortOrder: z.int().default(0),
+    createdAt: z.coerce.date().default(() => new Date()),
+    updatedAt: z.coerce.date().default(() => new Date()),
+});
+export const multiCurrencyExchangeRateHistoryShape = z.object({
+    id: z.string().register(col, { pk: true }),
+    currencyCode: z.string(),
+    rate: z.number(),
+    source: z.string().default("manual"),
+    recordedAt: z.coerce.date().default(() => new Date()),
+});
+export const multiCurrencyPriceOverrideShape = z.object({
+    id: z.string().register(col, { pk: true }),
+    productId: z.string(),
+    currencyCode: z.string(),
+    price: z.number(),
+    compareAtPrice: z.number().optional(),
+    createdAt: z.coerce.date().default(() => new Date()),
+    updatedAt: z.coerce.date().default(() => new Date()),
+});
+/** Native Relational storage for multi-currency. */
+export const multiCurrencyStorage = {
+    kind: "relational",
+    tables: {
+        currency: {
+            shape: multiCurrencyCurrencyShape,
+        },
+        exchangeRateHistory: {
+            shape: multiCurrencyExchangeRateHistoryShape,
+        },
+        priceOverride: {
+            shape: multiCurrencyPriceOverrideShape,
+        },
+    },
+};

package/dist/service-impl.d.ts

@@ -0,0 +1,5 @@
+import type { ScopedEventEmitter } from "@86d-store/core/events";
+import type { ModuleDataService } from "@86d-store/core/types/module";
+import type { MultiCurrencyController } from "./service";
+export declare function createMultiCurrencyController(data: ModuleDataService, events?: ScopedEventEmitter): MultiCurrencyController;
+//# sourceMappingURL=service-impl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-impl.d.ts","sourceRoot":"","sources":["../src/service-impl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAIX,uBAAuB,EAGvB,MAAM,WAAW,CAAC;AAyCnB,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,iBAAiB,EACvB,MAAM,CAAC,EAAE,kBAAkB,GACzB,uBAAuB,CAibzB"}

package/dist/service-impl.js

@@ -0,0 +1,369 @@
+function applyRounding(amount, decimalPlaces, mode) {
+    const factor = 10 ** decimalPlaces;
+    switch (mode) {
+        case "ceil":
+            return Math.ceil(amount * factor) / factor;
+        case "floor":
+            return Math.floor(amount * factor) / factor;
+        default:
+            return Math.round(amount * factor) / factor;
+    }
+}
+function formatAmount(amount, currency) {
+    const fixed = amount.toFixed(currency.decimalPlaces);
+    const [intPart, decPart] = fixed.split(".");
+    // Apply thousands separator
+    let formattedInt = intPart;
+    if (currency.thousandsSeparator) {
+        formattedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, currency.thousandsSeparator);
+    }
+    const formattedNumber = currency.decimalPlaces > 0
+        ? `${formattedInt}${currency.decimalSeparator}${decPart}`
+        : formattedInt;
+    return currency.symbolPosition === "before"
+        ? `${currency.symbol}${formattedNumber}`
+        : `${formattedNumber}${currency.symbol}`;
+}
+export function createMultiCurrencyController(data, events) {
+    async function getCurrencyByCode(code) {
+        const results = (await data.findMany("currency", {
+            where: { code: code.toUpperCase() },
+            take: 1,
+        }));
+        return results[0] ?? null;
+    }
+    return {
+        async create(params) {
+            const id = crypto.randomUUID();
+            const now = new Date();
+            const code = params.code.toUpperCase();
+            // If this is set as base, ensure rate is 1
+            const isBase = params.isBase ?? false;
+            const exchangeRate = isBase ? 1 : (params.exchangeRate ?? 1);
+            // If setting as base, unset any existing base
+            if (isBase) {
+                const existing = (await data.findMany("currency", {
+                    where: { isBase: true },
+                }));
+                for (const c of existing) {
+                    const record = { ...c, isBase: false, updatedAt: now };
+                    await data.upsert("currency", c.id, record);
+                }
+            }
+            const currency = {
+                id,
+                code,
+                name: params.name,
+                symbol: params.symbol,
+                decimalPlaces: params.decimalPlaces ?? 2,
+                exchangeRate,
+                isBase,
+                isActive: params.isActive ?? true,
+                symbolPosition: params.symbolPosition ?? "before",
+                thousandsSeparator: params.thousandsSeparator ?? ",",
+                decimalSeparator: params.decimalSeparator ?? ".",
+                roundingMode: params.roundingMode ?? "round",
+                sortOrder: params.sortOrder ?? 0,
+                createdAt: now,
+                updatedAt: now,
+            };
+            await data.upsert("currency", id, currency);
+            if (events) {
+                void events.emit("currency.created", {
+                    id: currency.id,
+                    code: currency.code,
+                });
+            }
+            return currency;
+        },
+        async getById(id) {
+            return (await data.get("currency", id));
+        },
+        async getByCode(code) {
+            return getCurrencyByCode(code);
+        },
+        async update(id, params) {
+            const existing = (await data.get("currency", id));
+            if (!existing)
+                return null;
+            const updated = {
+                ...existing,
+                ...(params.name !== undefined ? { name: params.name } : {}),
+                ...(params.symbol !== undefined ? { symbol: params.symbol } : {}),
+                ...(params.decimalPlaces !== undefined
+                    ? { decimalPlaces: params.decimalPlaces }
+                    : {}),
+                ...(params.exchangeRate !== undefined
+                    ? { exchangeRate: params.exchangeRate }
+                    : {}),
+                ...(params.isActive !== undefined ? { isActive: params.isActive } : {}),
+                ...(params.symbolPosition !== undefined
+                    ? { symbolPosition: params.symbolPosition }
+                    : {}),
+                ...(params.thousandsSeparator !== undefined
+                    ? { thousandsSeparator: params.thousandsSeparator }
+                    : {}),
+                ...(params.decimalSeparator !== undefined
+                    ? { decimalSeparator: params.decimalSeparator }
+                    : {}),
+                ...(params.roundingMode !== undefined
+                    ? { roundingMode: params.roundingMode }
+                    : {}),
+                ...(params.sortOrder !== undefined
+                    ? { sortOrder: params.sortOrder }
+                    : {}),
+                updatedAt: new Date(),
+            };
+            await data.upsert("currency", id, updated);
+            if (events) {
+                void events.emit("currency.updated", {
+                    id: updated.id,
+                    code: updated.code,
+                });
+            }
+            return updated;
+        },
+        async delete(id) {
+            const currency = (await data.get("currency", id));
+            if (!currency) {
+                return { deleted: false, error: "Currency not found" };
+            }
+            if (currency.isBase) {
+                return {
+                    deleted: false,
+                    error: "Cannot delete the base currency",
+                };
+            }
+            // Delete price overrides for this currency
+            const overrides = (await data.findMany("priceOverride", {
+                where: { currencyCode: currency.code },
+            }));
+            for (const o of overrides) {
+                await data.delete("priceOverride", o.id);
+            }
+            // Delete rate history
+            const history = (await data.findMany("exchangeRateHistory", {
+                where: { currencyCode: currency.code },
+            }));
+            for (const h of history) {
+                await data.delete("exchangeRateHistory", h.id);
+            }
+            await data.delete("currency", id);
+            if (events) {
+                void events.emit("currency.deleted", {
+                    id: currency.id,
+                    code: currency.code,
+                });
+            }
+            return { deleted: true };
+        },
+        async list(params) {
+            const where = params?.activeOnly ? { isActive: true } : {};
+            const currencies = (await data.findMany("currency", {
+                where,
+            }));
+            currencies.sort((a, b) => a.sortOrder - b.sortOrder);
+            return currencies;
+        },
+        async getBaseCurrency() {
+            const results = (await data.findMany("currency", {
+                where: { isBase: true },
+                take: 1,
+            }));
+            return results[0] ?? null;
+        },
+        async setBaseCurrency(id) {
+            const currency = (await data.get("currency", id));
+            if (!currency)
+                return null;
+            const now = new Date();
+            // Unset existing base currencies
+            const existing = (await data.findMany("currency", {
+                where: { isBase: true },
+            }));
+            for (const c of existing) {
+                if (c.id !== id) {
+                    const record = { ...c, isBase: false, updatedAt: now };
+                    await data.upsert("currency", c.id, record);
+                }
+            }
+            const updated = {
+                ...currency,
+                isBase: true,
+                exchangeRate: 1,
+                updatedAt: now,
+            };
+            await data.upsert("currency", id, updated);
+            if (events) {
+                void events.emit("currency.baseChanged", {
+                    id: updated.id,
+                    code: updated.code,
+                });
+            }
+            return updated;
+        },
+        async updateRate(params) {
+            const currency = await getCurrencyByCode(params.currencyCode);
+            if (!currency)
+                return null;
+            if (currency.isBase)
+                return currency; // Base rate is always 1
+            const now = new Date();
+            // Record history
+            const historyId = crypto.randomUUID();
+            const historyEntry = {
+                id: historyId,
+                currencyCode: currency.code,
+                rate: params.rate,
+                source: params.source ?? "manual",
+                recordedAt: now,
+            };
+            await data.upsert("exchangeRateHistory", historyId, historyEntry);
+            // Update the currency
+            const updated = {
+                ...currency,
+                exchangeRate: params.rate,
+                updatedAt: now,
+            };
+            const updatedRecord = updated;
+            await data.upsert("currency", currency.id, updatedRecord);
+            if (events) {
+                void events.emit("currency.rateUpdated", {
+                    code: currency.code,
+                    oldRate: currency.exchangeRate,
+                    newRate: params.rate,
+                    source: params.source ?? "manual",
+                });
+            }
+            return updated;
+        },
+        async bulkUpdateRates(rates) {
+            let updated = 0;
+            const errors = [];
+            for (const entry of rates) {
+                const result = await this.updateRate(entry);
+                if (result) {
+                    updated++;
+                }
+                else {
+                    errors.push(`Currency not found: ${entry.currencyCode}`);
+                }
+            }
+            return { updated, errors };
+        },
+        async getRateHistory(params) {
+            const { currencyCode, limit = 50 } = params;
+            const history = (await data.findMany("exchangeRateHistory", {
+                where: { currencyCode: currencyCode.toUpperCase() },
+            }));
+            history.sort((a, b) => new Date(b.recordedAt).getTime() - new Date(a.recordedAt).getTime());
+            return history.slice(0, limit);
+        },
+        async convert(params) {
+            const { amount, to, from } = params;
+            const targetCurrency = await getCurrencyByCode(to);
+            if (!targetCurrency)
+                return null;
+            let convertedAmount;
+            if (from) {
+                // Convert from a non-base currency
+                const sourceCurrency = await getCurrencyByCode(from);
+                if (!sourceCurrency)
+                    return null;
+                // Convert to base first, then to target
+                const inBase = amount / sourceCurrency.exchangeRate;
+                convertedAmount = inBase * targetCurrency.exchangeRate;
+            }
+            else {
+                // Convert from base currency
+                convertedAmount = amount * targetCurrency.exchangeRate;
+            }
+            convertedAmount = applyRounding(convertedAmount, targetCurrency.decimalPlaces, targetCurrency.roundingMode);
+            return {
+                amount: convertedAmount,
+                currency: targetCurrency,
+                formatted: formatAmount(convertedAmount, targetCurrency),
+            };
+        },
+        async formatPrice(amount, currencyCode) {
+            const currency = await getCurrencyByCode(currencyCode);
+            if (!currency)
+                return null;
+            return formatAmount(amount, currency);
+        },
+        async setPriceOverride(params) {
+            const code = params.currencyCode.toUpperCase();
+            // Check if override exists for this product+currency
+            const existing = (await data.findMany("priceOverride", {
+                where: {
+                    productId: params.productId,
+                    currencyCode: code,
+                },
+                take: 1,
+            }));
+            const now = new Date();
+            const id = existing[0]?.id ?? crypto.randomUUID();
+            const override = {
+                id,
+                productId: params.productId,
+                currencyCode: code,
+                price: params.price,
+                compareAtPrice: params.compareAtPrice,
+                createdAt: existing[0]?.createdAt ?? now,
+                updatedAt: now,
+            };
+            await data.upsert("priceOverride", id, override);
+            return override;
+        },
+        async getPriceOverride(productId, currencyCode) {
+            const results = (await data.findMany("priceOverride", {
+                where: {
+                    productId,
+                    currencyCode: currencyCode.toUpperCase(),
+                },
+                take: 1,
+            }));
+            return results[0] ?? null;
+        },
+        async listPriceOverrides(productId) {
+            return (await data.findMany("priceOverride", {
+                where: { productId },
+            }));
+        },
+        async deletePriceOverride(id) {
+            await data.delete("priceOverride", id);
+        },
+        async getProductPrice(params) {
+            const { productId, basePriceInCents, currencyCode } = params;
+            const currency = await getCurrencyByCode(currencyCode);
+            if (!currency)
+                return null;
+            // Check for price override first
+            const override = await this.getPriceOverride(productId, currencyCode);
+            if (override) {
+                // Convert from cents to display amount
+                const displayAmount = override.price / 10 ** currency.decimalPlaces;
+                return {
+                    amount: override.price,
+                    currency,
+                    formatted: formatAmount(displayAmount, currency),
+                };
+            }
+            // Fall back to conversion from base currency
+            const baseCurrency = await this.getBaseCurrency();
+            if (!baseCurrency)
+                return null;
+            // Convert cents to base currency amount
+            const baseAmount = basePriceInCents / 10 ** baseCurrency.decimalPlaces;
+            const converted = baseAmount * currency.exchangeRate;
+            const rounded = applyRounding(converted, currency.decimalPlaces, currency.roundingMode);
+            // Return amount in smallest unit (cents)
+            const amountInSmallestUnit = Math.round(rounded * 10 ** currency.decimalPlaces);
+            return {
+                amount: amountInSmallestUnit,
+                currency,
+                formatted: formatAmount(rounded, currency),
+            };
+        },
+    };
+}