@uplab/vendure-plugin-exchange-rates 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @uplab/vendure-plugin-exchange-rates
+
+## 0.1.0
+
+### Minor Changes
+
+- [#30](https://github.com/Uplab/uplab-vendure-plugins/pull/30) [`d132726`](https://github.com/Uplab/uplab-vendure-plugins/commit/d132726b2fecf429684ae6e558db6d9b754c03b2) Thanks [@brmk](https://github.com/brmk)! - Initial release: exchange rates in your shop's base currency from a pluggable source (the ECB, Frankfurter, Monobank, the NBU, fixed rates or your own), cross rates derived automatically, refreshed on a schedule, served on the Shop API and overridable per currency in the dashboard.

package/README.md

@@ -0,0 +1,369 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Uplab/uplab-vendure-plugins/main/packages/vendure-plugin-exchange-rates/assets/icon.svg" alt="" width="96" height="96">
+</p>
+
+# @uplab/vendure-plugin-exchange-rates
+
+[![npm](https://img.shields.io/npm/v/@uplab/vendure-plugin-exchange-rates.svg)](https://www.npmjs.com/package/@uplab/vendure-plugin-exchange-rates)
+[![Vendure](https://img.shields.io/badge/Vendure-%5E3.7.0-17c9ff.svg)](https://www.vendure.io/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/Uplab/uplab-vendure-plugins/blob/main/LICENSE)
+
+Exchange rates in your shop's base currency, for a Vendure shop that prices in one currency and shows or
+charges in others. Rates come from a **source you choose** — the European Central Bank, Frankfurter,
+Monobank, the National Bank of Ukraine, fixed rates or your own — are re-based onto your currency, refreshed
+on a schedule, served on the Shop API, and can be overridden per currency in the dashboard.
+
+The plugin stores and serves rates; it does not touch Vendure prices or orders — your storefront, feed or
+payment code converts with them. Vendure's own per-currency variant prices are unaffected.
+
+![Exchange rates in the dashboard](https://raw.githubusercontent.com/Uplab/uplab-vendure-plugins/main/packages/vendure-plugin-exchange-rates/assets/screenshot-list.png)
+
+## Contents
+
+[Install](#install) · [Use cases](#use-cases) · [Sources](#sources) · [Base currency](#base-currency) ·
+[Options](#options) · [Dashboard](#dashboard) · [GraphQL API](#graphql-api) ·
+[In your own code](#in-your-own-code) · [Event](#event) · [Database](#database) · [Limitations](#limitations)
+
+## Install
+
+```bash
+npm install @uplab/vendure-plugin-exchange-rates
+# or
+pnpm add @uplab/vendure-plugin-exchange-rates
+```
+
+```ts
+import { DefaultSchedulerPlugin, VendureConfig } from '@vendure/core';
+import { EcbExchangeRateSource, ExchangeRatesPlugin } from '@uplab/vendure-plugin-exchange-rates';
+
+export const config: VendureConfig = {
+  // ...
+  plugins: [
+    DefaultSchedulerPlugin.init(), // runs the scheduled refresh
+    ExchangeRatesPlugin.init({ source: new EcbExchangeRateSource() }),
+  ],
+};
+```
+
+Rates are stored in the **default channel's currency**; see [Base currency](#base-currency) to pin another.
+
+`@vendure/core`, `@nestjs/*` and `typeorm` are peers. The dashboard pages need `@vendure/dashboard` (an
+optional peer): its Vite plugin discovers the extension — restart the dashboard dev server after
+installing.
+
+**First deploy.** Generate and run a migration for the new `currency_exchange_rate` table. On the API
+server's first boot the plugin fills the empty table from the source (startup waits for it, up to the
+source's `timeout`); if the source is unreachable then, the table stays empty until the next scheduled
+refresh. Every currency arrives **disabled** — enable the ones you sell in under _Settings → Currency
+exchange rates_. Until you do, the storefront sees no rates and stays in your base currency.
+
+## Use cases
+
+**Show prices in the visitor's currency.** The storefront reads the enabled rates once:
+
+```graphql
+query {
+  currencyExchangeRates {
+    items {
+      code
+      rate # base-currency units per one unit, e.g. a USD shop: EUR → 1.12
+    }
+  }
+}
+```
+
+```ts
+type Rate = { code: string; rate: number };
+
+/** `rates` = the query's items, [] until an admin enables a currency. */
+export function convertPrice(priceInMinorUnits: number, rates: Rate[], code: string): number | undefined {
+  const rate = rates.find((r) => r.code === code)?.rate;
+  // Vendure prices are minor units: base minor units ÷ rate = target minor units. undefined → show the base.
+  return rate ? Math.round(priceInMinorUnits / rate) : undefined;
+}
+```
+
+This assumes both currencies have 1/100 minor units. When they differ (JPY has none, KWD and BHD have
+1/1000), multiply the result by 10^(target digits − base digits).
+
+**Charge in a foreign currency.** A `PaymentMethodHandler` gets the service in `init` and converts the
+amount it is asked to collect:
+
+```ts
+import { CurrencyCode, LanguageCode, PaymentMethodHandler } from '@vendure/core';
+import { CurrencyExchangeRateService } from '@uplab/vendure-plugin-exchange-rates';
+
+let rates: CurrencyExchangeRateService;
+
+export const eurCardHandler = new PaymentMethodHandler({
+  code: 'eur-card',
+  description: [{ languageCode: LanguageCode.en, value: 'Card, billed in EUR' }],
+  args: {},
+  init: (injector) => {
+    rates = injector.get(CurrencyExchangeRateService);
+  },
+  createPayment: async (ctx, _order, amount) => {
+    const rate = await rates.getRate(ctx, CurrencyCode.EUR, { requireEnabled: true });
+    const amountInCents = rate ? Math.round(amount / rate) : undefined; // undefined → bill in the base
+    // …call your payment provider with amountInCents
+    return { amount, state: 'Authorized', metadata: { amountInCents } };
+  },
+  settlePayment: () => ({ success: true }),
+});
+```
+
+**Price a product feed in another currency** (Google Merchant, Meta, …) even if the storefront does not
+offer it: `getRate(ctx, CurrencyCode.EUR, { requireEnabled: false })`.
+
+**Pin a rate.** Turn on _Use custom rate_ for a currency: the storefront and your code use your number
+until you turn it off, while the fetched rate keeps updating underneath.
+
+**Fixed rates only.** `source: new StaticExchangeRateSource({ base: CurrencyCode.USD, rates: { EUR: 1.12 } })`.
+Keep the sync on, so a number you change in config is picked up on the next refresh; pin any currency in
+the meantime with _Use custom rate_.
+
+## Sources
+
+| Source                          | Base           | Rates                                                                                                            |
+| ------------------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `EcbExchangeRateSource`         | EUR            | The ECB's euro reference rates: ~30 major currencies, every working day around 16:00 CET. Free, no key.          |
+| `FrankfurterExchangeRateSource` | EUR, or `base` | [Frankfurter](https://frankfurter.dev): the same ECB rates as JSON. Free, no key, can be self-hosted (`apiUrl`). |
+| `StaticExchangeRateSource`      | yours          | The numbers you pass: `{ base, rates }`. In e2e tests, set `source.config` before a sync — no network.           |
+| `MonobankExchangeRateSource`    | UAH            | [Ukrainian](#ukrainian-sources) bank rates, buy/sell/mid.                                                        |
+| `NbuExchangeRateSource`         | UAH            | [Ukrainian](#ukrainian-sources) official rates, ~40 currencies.                                                  |
+
+The network sources take `apiUrl` and `timeout` (default 10 s). Whatever a source returns, only Vendure
+`CurrencyCode`s with a positive finite rate are stored — metals, the SDR and garbage are dropped. If the
+source fails or returns nothing usable, the stored rates stay as they are.
+
+**Cross rates.** A source that quotes against another base is re-based onto yours: with the ECB and a USD
+shop, `GBP = (EUR per GBP) / (EUR per USD)`, and EUR itself is added. This needs the source to quote your
+base currency — the ECB does not quote UAH, for instance, so a UAH shop uses a Ukrainian source. Rates are
+stored per unit with 8 decimals, so a weak currency against a strong base keeps few significant digits
+(LBP in USD: 0.00001117); a rate that does not fit decimal(19, 8) is dropped.
+
+### Ukrainian sources
+
+- **`MonobankExchangeRateSource`** — Monobank's public rates. `side: 'buy'` (default) is what the bank pays
+  you for the currency — the lower rate, so a UAH price converted with it never comes up short; or
+  `'sell'`, `'mid'`. Rate-limited; cached 5 minutes.
+- **`NbuExchangeRateSource`** — the National Bank of Ukraine's official rate, set once per business day.
+
+Both quote against UAH, so they suit a UAH shop. They also work for a shop in a currency they quote (USD,
+EUR, …), but the ECB is the more natural choice there.
+
+### Your own source
+
+```ts
+import { CurrencyCode } from '@vendure/core';
+import {
+  ExchangeRateSource,
+  ExchangeRateSourceError,
+  ExchangeRateSourceResult,
+} from '@uplab/vendure-plugin-exchange-rates';
+
+type Observation = { d: string } & Record<string, { v: string } | string>;
+
+/** Rates of the Bank of Canada: CAD per one unit. */
+export class BankOfCanadaExchangeRateSource implements ExchangeRateSource {
+  readonly name = 'bank-of-canada';
+
+  async fetchRates(): Promise<ExchangeRateSourceResult> {
+    const res = await fetch('https://www.bankofcanada.ca/valet/observations/group/FX_RATES_DAILY/json?recent=1', {
+      signal: AbortSignal.timeout(10_000), // the API server waits for the first fetch on boot
+    });
+    if (!res.ok) throw new ExchangeRateSourceError(`HTTP ${res.status}`, { source: this.name, status: res.status });
+    const body = (await res.json()) as { observations?: Observation[] };
+    if (!body.observations?.length) throw new ExchangeRateSourceError('No observations', { source: this.name });
+    // `recent=1` is the last value of every series, discontinued ones included: keep the newest day.
+    const latest = body.observations.reduce((a, b) => (a.d > b.d ? a : b));
+    const quotes = Object.entries(latest)
+      .filter(([series]) => /^FX[A-Z]{3}CAD$/.test(series))
+      .map(([series, value]) => ({
+        currencyCode: series.slice(2, 5) as CurrencyCode,
+        rate: Number((value as { v: string }).v),
+      }));
+    return { base: CurrencyCode.CAD, quotes };
+  }
+}
+```
+
+A source returns its `base` and quotes `{ currencyCode, rate }`, `rate` being **base units per one unit**;
+the plugin re-bases them onto the shop's currency. Throw on failure — never return an empty list to mean
+"failed" — and give the request a timeout, since the API server waits for the first fetch on boot. If the
+source needs services, implement `init(injector)` (and `destroy()`); the plugin calls `init` before the
+first fetch.
+
+### Combining sources
+
+When a source rate-limits or is down, fall back to another — the first one that answers wins:
+
+```ts
+import { RequestContext } from '@vendure/core';
+import {
+  EcbExchangeRateSource,
+  ExchangeRateSource,
+  ExchangeRateSourceResult,
+  FrankfurterExchangeRateSource,
+} from '@uplab/vendure-plugin-exchange-rates';
+
+export class FallbackExchangeRateSource implements ExchangeRateSource {
+  readonly name = 'fallback';
+  constructor(private readonly sources: ExchangeRateSource[]) {}
+
+  async fetchRates(ctx: RequestContext): Promise<ExchangeRateSourceResult> {
+    let lastError: unknown;
+    for (const source of this.sources) {
+      try {
+        return await source.fetchRates(ctx);
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    throw lastError;
+  }
+}
+
+export const source = new FallbackExchangeRateSource([
+  new EcbExchangeRateSource(),
+  new FrankfurterExchangeRateSource(),
+]);
+```
+
+To add a currency a source does not quote, merge the quotes of several sources **in the same base** (a
+`StaticExchangeRateSource` last); when two quotes share a code, the last one wins. Forward `init`/`destroy`
+if the inner sources need them.
+
+## Base currency
+
+Rates are stored and served in one base currency: `baseCurrency` if you set it, otherwise the default
+channel's `defaultCurrencyCode`, read on every sync and lookup.
+
+```ts
+ExchangeRatesPlugin.init({ source: new MonobankExchangeRateSource(), baseCurrency: CurrencyCode.UAH });
+```
+
+When the base changes, the Shop API and `getRate` return nothing until a sync re-bases the table. The API
+server does that on boot, so changing the option needs nothing more; after changing the default channel's
+currency, run the task (see [Options](#options)) or restart. The sync moves every currency to the new
+base, keeps whether it is enabled, **drops its custom rate** (it was in the old base) and deletes the
+currencies the new base does not cover.
+
+## Options
+
+| Option         | Type                                                      | Default                           |
+| -------------- | --------------------------------------------------------- | --------------------------------- |
+| `source`       | `ExchangeRateSource` — required                           | —                                 |
+| `baseCurrency` | `CurrencyCode`                                            | the default channel's currency    |
+| `sync`         | `{ schedule?: ScheduledTaskConfig['schedule'] } \| false` | `{ schedule: '40 2-23/3 * * *' }` |
+
+`sync` registers the scheduled task `currency-exchange-rate-updater` (`SYNC_TASK_ID`, every 3 hours). It
+needs a scheduler plugin such as `DefaultSchedulerPlugin`, and runs in the worker — so the worker needs the
+plugin in its config too. `sync: false` leaves it out; you can still call `CurrencyExchangeRateSyncService.syncRates(ctx)`.
+
+To refresh now, run it under _System → Scheduled tasks_ (or
+`runScheduledTask(id: "currency-exchange-rate-updater")`); its last run there tells you the sync is alive.
+A sync moves a row's `updatedAt` only when its rate changes. A currency the source stops quoting keeps its
+last rate; if it is enabled, every sync logs a warning.
+
+## Dashboard
+
+_Settings → Currency exchange rates_ lists every stored currency with its rate and base, whether it is
+enabled and whether a custom rate is in use. A currency's page shows the fetched rate and lets you enable
+it and set a custom rate.
+
+![Editing a currency](https://raw.githubusercontent.com/Uplab/uplab-vendure-plugins/main/packages/vendure-plugin-exchange-rates/assets/screenshot-detail.png)
+
+Rates are shop settings: listing needs `ReadSettings`, editing `UpdateSettings` — no extra role setup.
+
+## GraphQL API
+
+**Shop** (public)
+
+```graphql
+currencyExchangeRates(options: CurrencyExchangeRateListOptions): CurrencyExchangeRateList!
+# items: { id, code, baseCurrency, rate, enabled, createdAt, updatedAt }
+# enabled currencies in the current base only, whatever the filter
+```
+
+`rate` is the custom rate while one is in use, otherwise the fetched one.
+
+**Admin**
+
+```graphql
+currencyExchangeRates(options: CurrencyExchangeRateListOptions): CurrencyExchangeRateList!          # ReadSettings
+currencyExchangeRate(id: ID!): CurrencyExchangeRate                                                 # ReadSettings
+updateCurrencyExchangeRate(input: { id, enabled, useCustomRate, customRate }): CurrencyExchangeRate! # UpdateSettings
+```
+
+In the Admin API `rate` is always the fetched rate; `useCustomRate` and `customRate` are separate fields.
+Turning on `useCustomRate` without a positive `customRate` is rejected.
+
+## In your own code
+
+| Export                            | Use                                                                                                                                   |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
+| `CurrencyExchangeRateService`     | `getRate(ctx, code, { requireEnabled })` → base units per unit or `undefined`; `getBaseCurrency(ctx)`; `findAll`, `findOne`, `update` |
+| `CurrencyExchangeRateSyncService` | `syncRates(ctx)` — refresh now                                                                                                        |
+| `effectiveRate(row)`              | The rate to convert with for a row you loaded yourself, or `undefined` if it is not usable                                            |
+
+`requireEnabled` is your policy: `true` for anything the customer is billed in, `false` for internal uses.
+
+## Event
+
+`CurrencyExchangeRateEvent` is published once the transaction has committed: `type: 'synced'` when a sync
+changed anything, with every rate now stored in the base currency, or `'updated'` with the one rate an
+admin saved. Use it to drop caches
+that embed the rates:
+
+```ts
+import { OnApplicationBootstrap } from '@nestjs/common';
+import { EventBus, PluginCommonModule, VendurePlugin } from '@vendure/core';
+import { CurrencyExchangeRateEvent } from '@uplab/vendure-plugin-exchange-rates';
+
+@VendurePlugin({ imports: [PluginCommonModule] })
+export class RatesCachePlugin implements OnApplicationBootstrap {
+  constructor(private readonly eventBus: EventBus) {}
+
+  onApplicationBootstrap() {
+    this.eventBus.ofType(CurrencyExchangeRateEvent).subscribe(() => {
+      // drop whatever caches the rates, e.g. a cached Shop API response
+    });
+  }
+}
+```
+
+## Database
+
+One table, `currency_exchange_rate`:
+
+| Column          | Type                                        |
+| --------------- | ------------------------------------------- |
+| `code`          | varchar, unique                             |
+| `baseCurrency`  | varchar — the currency `rate` is counted in |
+| `rate`          | decimal(19, 8) — the fetched one            |
+| `enabled`       | boolean, default `false`                    |
+| `useCustomRate` | boolean, default `false`                    |
+| `customRate`    | decimal(19, 8), nullable                    |
+
+A sync updates `rate` and inserts new currencies, in one transaction; on a [base change](#base-currency) it
+also rewrites `baseCurrency`, clears custom rates and deletes the currencies the new base does not cover.
+
+## Limitations
+
+- **One base currency** — channels that sell in different currencies share the rates of the default
+  channel's (or `baseCurrency`).
+- **Rates are global** — one table, not per channel: anyone with `UpdateSettings` in any channel can
+  change them.
+- **Filtering and sorting on `rate`** use the fetched rate, while the returned `rate` is the effective one.
+- **Dashboard 3.7.0–3.7.3 in dev mode** can render a blank page with two or more dashboard extensions
+  (for example together with `@uplab/vendure-plugin-unified-slug`). It is a Vendure bug, fixed in 3.7.4
+  ([vendure#5459](https://github.com/vendure-ecommerce/vendure/pull/5459)); production builds are fine.
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md).
+
+## License
+
+MIT

package/dist/api/admin.resolver.d.ts

@@ -0,0 +1,16 @@
+import { ID, ListQueryOptions, PaginatedList, RequestContext } from '@vendure/core';
+import { CurrencyExchangeRate } from '../entities/currency-exchange-rate.entity';
+import { CurrencyExchangeRateService } from '../services/currency-exchange-rate.service';
+import { MutationUpdateCurrencyExchangeRateArgs } from '../types';
+export declare class CurrencyExchangeRateAdminResolver {
+    private currencyExchangeRateService;
+    constructor(currencyExchangeRateService: CurrencyExchangeRateService);
+    currencyExchangeRates(ctx: RequestContext, args: {
+        options: ListQueryOptions<CurrencyExchangeRate>;
+    }): Promise<PaginatedList<CurrencyExchangeRate>>;
+    currencyExchangeRate(ctx: RequestContext, args: {
+        id: ID;
+    }): Promise<CurrencyExchangeRate | null>;
+    updateCurrencyExchangeRate(ctx: RequestContext, args: MutationUpdateCurrencyExchangeRateArgs): Promise<CurrencyExchangeRate>;
+}
+//# sourceMappingURL=admin.resolver.d.ts.map

package/dist/api/admin.resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.resolver.d.ts","sourceRoot":"","sources":["../../src/api/admin.resolver.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,EAAE,EACF,gBAAgB,EAChB,aAAa,EAEb,cAAc,EAEf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACzF,OAAO,EAAE,sCAAsC,EAAE,MAAM,UAAU,CAAC;AAElE,qBACa,iCAAiC;IAChC,OAAO,CAAC,2BAA2B;gBAA3B,2BAA2B,EAAE,2BAA2B;IAI5E,qBAAqB,CACZ,GAAG,EAAE,cAAc,EAClB,IAAI,EAAE;QAAE,OAAO,EAAE,gBAAgB,CAAC,oBAAoB,CAAC,CAAA;KAAE,GAChE,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;IAM/C,oBAAoB,CAAQ,GAAG,EAAE,cAAc,EAAU,IAAI,EAAE;QAAE,EAAE,EAAE,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IAOhH,0BAA0B,CACjB,GAAG,EAAE,cAAc,EAClB,IAAI,EAAE,sCAAsC,GACnD,OAAO,CAAC,oBAAoB,CAAC;CAGjC"}

package/dist/api/admin.resolver.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrencyExchangeRateAdminResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const currency_exchange_rate_service_1 = require("../services/currency-exchange-rate.service");
+let CurrencyExchangeRateAdminResolver = class CurrencyExchangeRateAdminResolver {
+    constructor(currencyExchangeRateService) {
+        this.currencyExchangeRateService = currencyExchangeRateService;
+    }
+    currencyExchangeRates(ctx, args) {
+        return this.currencyExchangeRateService.findAll(ctx, args.options);
+    }
+    currencyExchangeRate(ctx, args) {
+        return this.currencyExchangeRateService.findOne(ctx, args.id);
+    }
+    updateCurrencyExchangeRate(ctx, args) {
+        return this.currencyExchangeRateService.update(ctx, args.input);
+    }
+};
+exports.CurrencyExchangeRateAdminResolver = CurrencyExchangeRateAdminResolver;
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(core_1.Permission.ReadSettings),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], CurrencyExchangeRateAdminResolver.prototype, "currencyExchangeRates", null);
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(core_1.Permission.ReadSettings),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], CurrencyExchangeRateAdminResolver.prototype, "currencyExchangeRate", null);
+__decorate([
+    (0, core_1.Transaction)(),
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Allow)(core_1.Permission.UpdateSettings),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], CurrencyExchangeRateAdminResolver.prototype, "updateCurrencyExchangeRate", null);
+exports.CurrencyExchangeRateAdminResolver = CurrencyExchangeRateAdminResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [currency_exchange_rate_service_1.CurrencyExchangeRateService])
+], CurrencyExchangeRateAdminResolver);
+//# sourceMappingURL=admin.resolver.js.map

package/dist/api/admin.resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin.resolver.js","sourceRoot":"","sources":["../../src/api/admin.resolver.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,6CAAkE;AAClE,wCASuB;AAEvB,+FAAyF;AAIlF,IAAM,iCAAiC,GAAvC,MAAM,iCAAiC;IAC5C,YAAoB,2BAAwD;QAAxD,gCAA2B,GAA3B,2BAA2B,CAA6B;IAAG,CAAC;IAIhF,qBAAqB,CACZ,GAAmB,EAClB,IAAyD;QAEjE,OAAO,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACrE,CAAC;IAID,oBAAoB,CAAQ,GAAmB,EAAU,IAAgB;QACvE,OAAO,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;IAChE,CAAC;IAKD,0BAA0B,CACjB,GAAmB,EAClB,IAA4C;QAEpD,OAAO,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAClE,CAAC;CACF,CAAA;AA3BY,8EAAiC;AAK5C;IAFC,IAAA,eAAK,GAAE;IACP,IAAA,YAAK,EAAC,iBAAU,CAAC,YAAY,CAAC;IAE5B,WAAA,IAAA,UAAG,GAAE,CAAA;IACL,WAAA,IAAA,cAAI,GAAE,CAAA;;qCADK,qBAAc;;8EAI3B;AAID;IAFC,IAAA,eAAK,GAAE;IACP,IAAA,YAAK,EAAC,iBAAU,CAAC,YAAY,CAAC;IACT,WAAA,IAAA,UAAG,GAAE,CAAA;IAAuB,WAAA,IAAA,cAAI,GAAE,CAAA;;qCAAvB,qBAAc;;6EAE9C;AAKD;IAHC,IAAA,kBAAW,GAAE;IACb,IAAA,kBAAQ,GAAE;IACV,IAAA,YAAK,EAAC,iBAAU,CAAC,cAAc,CAAC;IAE9B,WAAA,IAAA,UAAG,GAAE,CAAA;IACL,WAAA,IAAA,cAAI,GAAE,CAAA;;qCADK,qBAAc;;mFAI3B;4CA1BU,iCAAiC;IAD7C,IAAA,kBAAQ,GAAE;qCAEwC,4DAA2B;GADjE,iCAAiC,CA2B7C"}

package/dist/api/api-extensions.d.ts

@@ -0,0 +1,6 @@
+import gql from 'graphql-tag';
+type Document = ReturnType<typeof gql>;
+export declare const shopApiExtensions: Document;
+export declare const adminApiExtensions: Document;
+export {};
+//# sourceMappingURL=api-extensions.d.ts.map

package/dist/api/api-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-extensions.d.ts","sourceRoot":"","sources":["../../src/api/api-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,aAAa,CAAC;AAE9B,KAAK,QAAQ,GAAG,UAAU,CAAC,OAAO,GAAG,CAAC,CAAC;AA0BvC,eAAO,MAAM,iBAAiB,EAAE,QAE/B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,QAsBhC,CAAC"}

package/dist/api/api-extensions.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminApiExtensions = exports.shopApiExtensions = void 0;
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+const commonApiExtensions = (0, graphql_tag_1.default) `
+  type CurrencyExchangeRate implements Node {
+    id: ID!
+    createdAt: DateTime!
+    updatedAt: DateTime!
+    code: String!
+    "The currency rate is expressed in: rate = units of it per one unit of code."
+    baseCurrency: String!
+    rate: Float!
+    enabled: Boolean!
+  }
+
+  type CurrencyExchangeRateList implements PaginatedList {
+    items: [CurrencyExchangeRate!]!
+    totalItems: Int!
+  }
+
+  extend type Query {
+    currencyExchangeRates(options: CurrencyExchangeRateListOptions): CurrencyExchangeRateList!
+  }
+
+  input CurrencyExchangeRateListOptions
+`;
+exports.shopApiExtensions = (0, graphql_tag_1.default) `
+  ${commonApiExtensions}
+`;
+exports.adminApiExtensions = (0, graphql_tag_1.default) `
+  ${commonApiExtensions}
+
+  extend type CurrencyExchangeRate {
+    useCustomRate: Boolean!
+    customRate: Float
+  }
+
+  extend type Query {
+    currencyExchangeRate(id: ID!): CurrencyExchangeRate
+  }
+
+  extend type Mutation {
+    updateCurrencyExchangeRate(input: UpdateCurrencyExchangeRateInput!): CurrencyExchangeRate!
+  }
+
+  input UpdateCurrencyExchangeRateInput {
+    id: ID!
+    enabled: Boolean!
+    useCustomRate: Boolean!
+    customRate: Float
+  }
+`;
+//# sourceMappingURL=api-extensions.js.map

package/dist/api/api-extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-extensions.js","sourceRoot":"","sources":["../../src/api/api-extensions.ts"],"names":[],"mappings":";;;;;;AAAA,8DAA8B;AAI9B,MAAM,mBAAmB,GAAa,IAAA,qBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;CAsBxC,CAAC;AAEW,QAAA,iBAAiB,GAAa,IAAA,qBAAG,EAAA;IAC1C,mBAAmB;CACtB,CAAC;AAEW,QAAA,kBAAkB,GAAa,IAAA,qBAAG,EAAA;IAC3C,mBAAmB;;;;;;;;;;;;;;;;;;;;;CAqBtB,CAAC"}

package/dist/api/shop.resolver.d.ts

@@ -0,0 +1,15 @@
+import { ListQueryOptions, PaginatedList, RequestContext } from '@vendure/core';
+import { CurrencyExchangeRate } from '../entities/currency-exchange-rate.entity';
+import { CurrencyExchangeRateService } from '../services/currency-exchange-rate.service';
+export declare class CurrencyExchangeRateShopResolver {
+    private currencyExchangeRateService;
+    constructor(currencyExchangeRateService: CurrencyExchangeRateService);
+    /** Only the currencies an admin enabled, in the current base: the storefront offers nothing else. */
+    currencyExchangeRates(ctx: RequestContext, args: {
+        options?: ListQueryOptions<CurrencyExchangeRate>;
+    }): Promise<PaginatedList<CurrencyExchangeRate>>;
+}
+export declare class CurrencyExchangeRateShopFieldResolver {
+    rate(currencyExchangeRate: CurrencyExchangeRate): number;
+}
+//# sourceMappingURL=shop.resolver.d.ts.map

package/dist/api/shop.resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shop.resolver.d.ts","sourceRoot":"","sources":["../../src/api/shop.resolver.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,gBAAgB,EAAE,aAAa,EAAc,cAAc,EAAE,MAAM,eAAe,CAAC;AACxG,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAEjF,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AAEzF,qBACa,gCAAgC;IAC/B,OAAO,CAAC,2BAA2B;gBAA3B,2BAA2B,EAAE,2BAA2B;IAE5E,qGAAqG;IAG/F,qBAAqB,CAClB,GAAG,EAAE,cAAc,EAClB,IAAI,EAAE;QAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,oBAAoB,CAAC,CAAA;KAAE,GACjE,OAAO,CAAC,aAAa,CAAC,oBAAoB,CAAC,CAAC;CAMhD;AAED,qBACa,qCAAqC;IAEhD,IAAI,CAAC,oBAAoB,EAAE,oBAAoB;CAIhD"}

package/dist/api/shop.resolver.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrencyExchangeRateShopFieldResolver = exports.CurrencyExchangeRateShopResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const currency_exchange_rate_entity_1 = require("../entities/currency-exchange-rate.entity");
+const effective_rate_1 = require("../effective-rate");
+const currency_exchange_rate_service_1 = require("../services/currency-exchange-rate.service");
+let CurrencyExchangeRateShopResolver = class CurrencyExchangeRateShopResolver {
+    constructor(currencyExchangeRateService) {
+        this.currencyExchangeRateService = currencyExchangeRateService;
+    }
+    /** Only the currencies an admin enabled, in the current base: the storefront offers nothing else. */
+    async currencyExchangeRates(ctx, args) {
+        return this.currencyExchangeRateService.findAll(ctx, args.options, {
+            enabled: true,
+            baseCurrency: await this.currencyExchangeRateService.getBaseCurrency(ctx),
+        });
+    }
+};
+exports.CurrencyExchangeRateShopResolver = CurrencyExchangeRateShopResolver;
+__decorate([
+    (0, graphql_1.Query)(),
+    (0, core_1.Allow)(core_1.Permission.Public),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], CurrencyExchangeRateShopResolver.prototype, "currencyExchangeRates", null);
+exports.CurrencyExchangeRateShopResolver = CurrencyExchangeRateShopResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [currency_exchange_rate_service_1.CurrencyExchangeRateService])
+], CurrencyExchangeRateShopResolver);
+let CurrencyExchangeRateShopFieldResolver = class CurrencyExchangeRateShopFieldResolver {
+    rate(currencyExchangeRate) {
+        // The Admin API forbids a custom rate that is on but empty, so this falls back only for old rows.
+        return (0, effective_rate_1.effectiveRate)(currencyExchangeRate) ?? currencyExchangeRate.rate;
+    }
+};
+exports.CurrencyExchangeRateShopFieldResolver = CurrencyExchangeRateShopFieldResolver;
+__decorate([
+    (0, graphql_1.ResolveField)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [currency_exchange_rate_entity_1.CurrencyExchangeRate]),
+    __metadata("design:returntype", void 0)
+], CurrencyExchangeRateShopFieldResolver.prototype, "rate", null);
+exports.CurrencyExchangeRateShopFieldResolver = CurrencyExchangeRateShopFieldResolver = __decorate([
+    (0, graphql_1.Resolver)('CurrencyExchangeRate')
+], CurrencyExchangeRateShopFieldResolver);
+//# sourceMappingURL=shop.resolver.js.map

package/dist/api/shop.resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shop.resolver.js","sourceRoot":"","sources":["../../src/api/shop.resolver.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,6CAAsE;AACtE,wCAAwG;AACxG,6FAAiF;AACjF,sDAAkD;AAClD,+FAAyF;AAGlF,IAAM,gCAAgC,GAAtC,MAAM,gCAAgC;IAC3C,YAAoB,2BAAwD;QAAxD,gCAA2B,GAA3B,2BAA2B,CAA6B;IAAG,CAAC;IAEhF,qGAAqG;IAG/F,AAAN,KAAK,CAAC,qBAAqB,CAClB,GAAmB,EAClB,IAA0D;QAElE,OAAO,IAAI,CAAC,2BAA2B,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE;YACjE,OAAO,EAAE,IAAI;YACb,YAAY,EAAE,MAAM,IAAI,CAAC,2BAA2B,CAAC,eAAe,CAAC,GAAG,CAAC;SAC1E,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AAfY,4EAAgC;AAMrC;IAFL,IAAA,eAAK,GAAE;IACP,IAAA,YAAK,EAAC,iBAAU,CAAC,MAAM,CAAC;IAEtB,WAAA,IAAA,UAAG,GAAE,CAAA;IACL,WAAA,IAAA,cAAI,GAAE,CAAA;;qCADK,qBAAc;;6EAO3B;2CAdU,gCAAgC;IAD5C,IAAA,kBAAQ,GAAE;qCAEwC,4DAA2B;GADjE,gCAAgC,CAe5C;AAGM,IAAM,qCAAqC,GAA3C,MAAM,qCAAqC;IAEhD,IAAI,CAAC,oBAA0C;QAC7C,kGAAkG;QAClG,OAAO,IAAA,8BAAa,EAAC,oBAAoB,CAAC,IAAI,oBAAoB,CAAC,IAAI,CAAC;IAC1E,CAAC;CACF,CAAA;AANY,sFAAqC;AAEhD;IADC,IAAA,sBAAY,GAAE;;qCACY,oDAAoB;;iEAG9C;gDALU,qCAAqC;IADjD,IAAA,kBAAQ,EAAC,sBAAsB,CAAC;GACpB,qCAAqC,CAMjD"}

package/dist/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const EXCHANGE_RATES_PLUGIN_OPTIONS: unique symbol;
+export declare const loggerCtx = "ExchangeRatesPlugin";
+/** Every 3 hours at minute 40. */
+export declare const DEFAULT_SYNC_SCHEDULE = "40 2-23/3 * * *";
+export declare const SYNC_TASK_ID = "currency-exchange-rate-updater";
+/** How long a source request may take before it is aborted, in milliseconds. */
+export declare const DEFAULT_SOURCE_TIMEOUT = 10000;
+/** decimal(19, 8) holds 11 integer digits. */
+export declare const MAX_RATE = 100000000000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,eAA0C,CAAC;AACrF,eAAO,MAAM,SAAS,wBAAwB,CAAC;AAE/C,kCAAkC;AAClC,eAAO,MAAM,qBAAqB,oBAAoB,CAAC;AAEvD,eAAO,MAAM,YAAY,mCAAmC,CAAC;AAE7D,gFAAgF;AAChF,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAE7C,8CAA8C;AAC9C,eAAO,MAAM,QAAQ,eAAO,CAAC"}