@deenruv/core 1.0.0

package/dist/config/promotion/promotion-condition.d.ts

@@ -0,0 +1,65 @@
+import { ConfigArg } from "@deenruv/common/lib/generated-types";
+import { RequestContext } from "../../api/common/request-context";
+import { ConfigArgs, ConfigArgValues, ConfigurableOperationDef, ConfigurableOperationDefOptions } from "../../common/configurable-operation";
+import { Order } from "../../entity/order/order.entity";
+import { Promotion } from "../../entity/promotion/promotion.entity";
+export type PromotionConditionState = Record<string, unknown>;
+export type CheckPromotionConditionResult = boolean | PromotionConditionState;
+/**
+ * @description
+ * A function which checks whether or not a given {@link Order} satisfies the {@link PromotionCondition}.
+ *
+ * The function should return either a `boolean` or and plain object type:
+ *
+ * * `false`: The condition is not satisfied - do not apply PromotionActions
+ * * `true`: The condition is satisfied, apply PromotionActions
+ * * `{ [key: string]: any; }`: The condition is satisfied, apply PromotionActions
+ * _and_ pass this object into the PromotionAction's `state` argument.
+ *
+ * @docsCategory promotions
+ * @docsPage promotion-condition
+ */
+export type CheckPromotionConditionFn<T extends ConfigArgs, R extends CheckPromotionConditionResult> = (ctx: RequestContext, order: Order, args: ConfigArgValues<T>, promotion: Promotion) => R | Promise<R>;
+/**
+ * @description
+ * This object is used to configure a PromotionCondition.
+ *
+ * @docsCategory promotions
+ * @docsPage promotion-condition
+ * @docsWeight 1
+ */
+export interface PromotionConditionConfig<T extends ConfigArgs, C extends string, R extends CheckPromotionConditionResult> extends ConfigurableOperationDefOptions<T> {
+    code: C;
+    check: CheckPromotionConditionFn<T, R>;
+    priorityValue?: number;
+}
+/**
+ * @description
+ * PromotionConditions are used to create {@link Promotion}s. The purpose of a PromotionCondition
+ * is to check the order against a particular predicate function (the `check` function) and to return
+ * `true` if the Order satisfies the condition, or `false` if it does not.
+ *
+ * @docsCategory promotions
+ * @docsPage promotion-condition
+ * @docsWeight 0
+ */
+export declare class PromotionCondition<T extends ConfigArgs = ConfigArgs, C extends string = string, R extends CheckPromotionConditionResult = any> extends ConfigurableOperationDef<T> {
+    /**
+     * @description
+     * Used to determine the order of application of multiple Promotions
+     * on the same Order. See the {@link Promotion} `priorityScore` field for
+     * more information.
+     *
+     * @default 0
+     */
+    readonly priorityValue: number;
+    private readonly checkFn;
+    get code(): C;
+    constructor(config: PromotionConditionConfig<T, C, R>);
+    /**
+     * @description
+     * This is the function which contains the conditional logic to decide whether
+     * a Promotion should apply to an Order. See {@link CheckPromotionConditionFn}.
+     */
+    check(ctx: RequestContext, order: Order, args: ConfigArg[], promotion: Promotion): Promise<R>;
+}

package/dist/config/promotion/promotion-condition.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromotionCondition = void 0;
+const configurable_operation_1 = require("../../common/configurable-operation");
+/**
+ * @description
+ * PromotionConditions are used to create {@link Promotion}s. The purpose of a PromotionCondition
+ * is to check the order against a particular predicate function (the `check` function) and to return
+ * `true` if the Order satisfies the condition, or `false` if it does not.
+ *
+ * @docsCategory promotions
+ * @docsPage promotion-condition
+ * @docsWeight 0
+ */
+class PromotionCondition extends configurable_operation_1.ConfigurableOperationDef {
+    get code() {
+        return super.code;
+    }
+    constructor(config) {
+        super(config);
+        this.checkFn = config.check;
+        this.priorityValue = config.priorityValue || 0;
+    }
+    /**
+     * @description
+     * This is the function which contains the conditional logic to decide whether
+     * a Promotion should apply to an Order. See {@link CheckPromotionConditionFn}.
+     */
+    async check(ctx, order, args, promotion) {
+        return this.checkFn(ctx, order, this.argsArrayToHash(args), promotion);
+    }
+}
+exports.PromotionCondition = PromotionCondition;
+//# sourceMappingURL=promotion-condition.js.map

package/dist/config/promotion/promotion-condition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promotion-condition.js","sourceRoot":"","sources":["../../../src/config/promotion/promotion-condition.ts"],"names":[],"mappings":";;;AAGA,gFAK6C;AAkD7C;;;;;;;;;GASG;AACH,MAAa,kBAIX,SAAQ,iDAA2B;IAYnC,IAAI,IAAI;QACN,OAAO,KAAK,CAAC,IAAS,CAAC;IACzB,CAAC;IAED,YAAY,MAAyC;QACnD,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC;QAC5B,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAK,CACT,GAAmB,EACnB,KAAY,EACZ,IAAiB,EACjB,SAAoB;QAEpB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;IACzE,CAAC;CACF;AAvCD,gDAuCC"}

package/dist/config/promotion/utils/facet-value-checker.d.ts

@@ -0,0 +1,53 @@
+import { ID } from "@deenruv/common/lib/shared-types";
+import { RequestContext } from "../../../api";
+import { TransactionalConnection } from "../../../connection/transactional-connection";
+import { OrderLine } from "../../../entity/order-line/order-line.entity";
+/**
+ * @description
+ * The FacetValueChecker is a helper class used to determine whether a given OrderLine consists
+ * of ProductVariants containing the given FacetValues.
+ *
+ * @example
+ * ```ts
+ * import { FacetValueChecker, LanguageCode, PromotionCondition, TransactionalConnection } from '\@deenruv/core';
+ *
+ * let facetValueChecker: FacetValueChecker;
+ *
+ * export const hasFacetValues = new PromotionCondition({
+ *   code: 'at_least_n_with_facets',
+ *   description: [
+ *     { languageCode: LanguageCode.en, value: 'Buy at least { minimum } products with the given facets' },
+ *   ],
+ *   args: {
+ *     minimum: { type: 'int' },
+ *     facets: { type: 'ID', list: true, ui: { component: 'facet-value-form-input' } },
+ *   },
+ *   init(injector) {
+ *     facetValueChecker = new FacetValueChecker(injector.get(TransactionalConnection));
+ *   },
+ *   async check(ctx, order, args) {
+ *     let matches = 0;
+ *     for (const line of order.lines) {
+ *       if (await facetValueChecker.hasFacetValues(line, args.facets)) {
+ *           matches += line.quantity;
+ *       }
+ *     }
+ *     return args.minimum <= matches;
+ *   },
+ * });
+ * ```
+ *
+ * @docsCategory Promotions
+ */
+export declare class FacetValueChecker {
+    private connection;
+    private variantCache;
+    constructor(connection: TransactionalConnection);
+    /**
+     * @description
+     * Checks a given {@link OrderLine} against the facetValueIds and returns
+     * `true` if the associated {@link ProductVariant} & {@link Product} together
+     * have *all* the specified {@link FacetValue}s.
+     */
+    hasFacetValues(orderLine: OrderLine, facetValueIds: ID[], ctx?: RequestContext): Promise<boolean>;
+}

package/dist/config/promotion/utils/facet-value-checker.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FacetValueChecker = void 0;
+const unique_1 = require("@deenruv/common/lib/unique");
+const ttl_cache_1 = require("../../../common/ttl-cache");
+const utils_1 = require("../../../common/utils");
+const product_variant_entity_1 = require("../../../entity/product-variant/product-variant.entity");
+/**
+ * @description
+ * The FacetValueChecker is a helper class used to determine whether a given OrderLine consists
+ * of ProductVariants containing the given FacetValues.
+ *
+ * @example
+ * ```ts
+ * import { FacetValueChecker, LanguageCode, PromotionCondition, TransactionalConnection } from '\@deenruv/core';
+ *
+ * let facetValueChecker: FacetValueChecker;
+ *
+ * export const hasFacetValues = new PromotionCondition({
+ *   code: 'at_least_n_with_facets',
+ *   description: [
+ *     { languageCode: LanguageCode.en, value: 'Buy at least { minimum } products with the given facets' },
+ *   ],
+ *   args: {
+ *     minimum: { type: 'int' },
+ *     facets: { type: 'ID', list: true, ui: { component: 'facet-value-form-input' } },
+ *   },
+ *   init(injector) {
+ *     facetValueChecker = new FacetValueChecker(injector.get(TransactionalConnection));
+ *   },
+ *   async check(ctx, order, args) {
+ *     let matches = 0;
+ *     for (const line of order.lines) {
+ *       if (await facetValueChecker.hasFacetValues(line, args.facets)) {
+ *           matches += line.quantity;
+ *       }
+ *     }
+ *     return args.minimum <= matches;
+ *   },
+ * });
+ * ```
+ *
+ * @docsCategory Promotions
+ */
+class FacetValueChecker {
+    constructor(connection) {
+        this.connection = connection;
+        this.variantCache = new ttl_cache_1.TtlCache({ ttl: 5000 });
+    }
+    /**
+     * @description
+     * Checks a given {@link OrderLine} against the facetValueIds and returns
+     * `true` if the associated {@link ProductVariant} & {@link Product} together
+     * have *all* the specified {@link FacetValue}s.
+     */
+    async hasFacetValues(orderLine, facetValueIds, ctx) {
+        let variant = this.variantCache.get(orderLine.productVariant.id);
+        if (!variant) {
+            variant = await this.connection
+                .getRepository(ctx, product_variant_entity_1.ProductVariant)
+                .findOne({
+                where: { id: orderLine.productVariant.id },
+                relations: ["product", "product.facetValues", "facetValues"],
+            })
+                .then((result) => result !== null && result !== void 0 ? result : undefined);
+            if (!variant) {
+                return false;
+            }
+            this.variantCache.set(variant.id, variant);
+        }
+        const allFacetValues = (0, unique_1.unique)([...variant.facetValues, ...variant.product.facetValues], "id");
+        return facetValueIds.reduce((result, id) => result && !!allFacetValues.find((fv) => (0, utils_1.idsAreEqual)(fv.id, id)), true);
+    }
+}
+exports.FacetValueChecker = FacetValueChecker;
+//# sourceMappingURL=facet-value-checker.js.map

package/dist/config/promotion/utils/facet-value-checker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"facet-value-checker.js","sourceRoot":"","sources":["../../../../src/config/promotion/utils/facet-value-checker.ts"],"names":[],"mappings":";;;AACA,uDAAoD;AAGpD,yDAAqD;AACrD,iDAAoD;AAGpD,mGAAwF;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAa,iBAAiB;IAG5B,YAAoB,UAAmC;QAAnC,eAAU,GAAV,UAAU,CAAyB;QAF/C,iBAAY,GAAG,IAAI,oBAAQ,CAAqB,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;IAEb,CAAC;IAC3D;;;;;OAKG;IACH,KAAK,CAAC,cAAc,CAClB,SAAoB,EACpB,aAAmB,EACnB,GAAoB;QAEpB,IAAI,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;QACjE,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU;iBAC5B,aAAa,CAAC,GAAG,EAAE,uCAAc,CAAC;iBAClC,OAAO,CAAC;gBACP,KAAK,EAAE,EAAE,EAAE,EAAE,SAAS,CAAC,cAAc,CAAC,EAAE,EAAE;gBAC1C,SAAS,EAAE,CAAC,SAAS,EAAE,qBAAqB,EAAE,aAAa,CAAC;aAC7D,CAAC;iBACD,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,SAAS,CAAC,CAAC;YACzC,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,OAAO,KAAK,CAAC;YACf,CAAC;YACD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC;QACD,MAAM,cAAc,GAAG,IAAA,eAAM,EAC3B,CAAC,GAAG,OAAO,CAAC,WAAW,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,EACxD,IAAI,CACL,CAAC;QACF,OAAO,aAAa,CAAC,MAAM,CACzB,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CACb,MAAM,IAAI,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAA,mBAAW,EAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EACjE,IAAe,CAChB,CAAC;IACJ,CAAC;CACF;AAvCD,8CAuCC"}

package/dist/config/refund/default-refund-process.d.ts

@@ -0,0 +1,9 @@
+import { RefundState } from "../../service/helpers/refund-state-machine/refund-state";
+import { RefundProcess } from "./refund-process";
+/**
+ * @description
+ * The default {@link RefundProcess}.
+ *
+ * @docsCategory payment
+ */
+export declare const defaultRefundProcess: RefundProcess<RefundState>;

package/dist/config/refund/default-refund-process.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRefundProcess = void 0;
+const generated_types_1 = require("@deenruv/common/lib/generated-types");
+let configService;
+let historyService;
+/**
+ * @description
+ * The default {@link RefundProcess}.
+ *
+ * @docsCategory payment
+ */
+exports.defaultRefundProcess = {
+    transitions: {
+        Pending: {
+            to: ["Settled", "Failed"],
+        },
+        Settled: {
+            to: [],
+        },
+        Failed: {
+            to: [],
+        },
+    },
+    async init(injector) {
+        const ConfigService = await import("../config.service.js").then((m) => m.ConfigService);
+        const HistoryService = await import("../../service/index.js").then((m) => m.HistoryService);
+        configService = injector.get(ConfigService);
+        historyService = injector.get(HistoryService);
+    },
+    onTransitionStart: async (fromState, toState, data) => {
+        return true;
+    },
+    onTransitionEnd: async (fromState, toState, data) => {
+        if (!historyService) {
+            throw new Error("HistoryService has not been initialized");
+        }
+        await historyService.createHistoryEntryForOrder({
+            ctx: data.ctx,
+            orderId: data.order.id,
+            type: generated_types_1.HistoryEntryType.ORDER_REFUND_TRANSITION,
+            data: {
+                refundId: data.refund.id,
+                from: fromState,
+                to: toState,
+                reason: data.refund.reason,
+            },
+        });
+    },
+};
+//# sourceMappingURL=default-refund-process.js.map

package/dist/config/refund/default-refund-process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-refund-process.js","sourceRoot":"","sources":["../../../src/config/refund/default-refund-process.ts"],"names":[],"mappings":";;;AAAA,yEAAuE;AAMvE,IAAI,aAAwD,CAAC;AAC7D,IAAI,cAA4D,CAAC;AAEjE;;;;;GAKG;AACU,QAAA,oBAAoB,GAA+B;IAC9D,WAAW,EAAE;QACX,OAAO,EAAE;YACP,EAAE,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;SAC1B;QACD,OAAO,EAAE;YACP,EAAE,EAAE,EAAE;SACP;QACD,MAAM,EAAE;YACN,EAAE,EAAE,EAAE;SACP;KACF;IACD,KAAK,CAAC,IAAI,CAAC,QAAQ;QACjB,MAAM,aAAa,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAC,IAAI,CAC7D,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CACvB,CAAC;QACF,MAAM,cAAc,GAAG,MAAM,MAAM,CAAC,wBAAwB,CAAC,CAAC,IAAI,CAChE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,cAAc,CACxB,CAAC;QACF,aAAa,GAAG,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC5C,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAChD,CAAC;IACD,iBAAiB,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,eAAe,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE;QAClD,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QACD,MAAM,cAAc,CAAC,0BAA0B,CAAC;YAC9C,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE;YACtB,IAAI,EAAE,kCAAgB,CAAC,uBAAuB;YAC9C,IAAI,EAAE;gBACJ,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE;gBACxB,IAAI,EAAE,SAAS;gBACf,EAAE,EAAE,OAAO;gBACX,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;aAC3B;SACF,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/config/refund/refund-process.d.ts

@@ -0,0 +1,30 @@
+import { OnTransitionEndFn, OnTransitionErrorFn, OnTransitionStartFn, Transitions } from "../../common/finite-state-machine/types";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { CustomRefundStates, RefundState, RefundTransitionData } from "../../service/helpers/refund-state-machine/refund-state";
+/**
+ * @description
+ * A RefundProcess is used to define the way the refund process works as in: what states a Refund can be
+ * in, and how it may transition from one state to another. Using the `onTransitionStart()` hook, a
+ * RefundProcess can perform checks before allowing a state transition to occur, and the `onTransitionEnd()`
+ * hook allows logic to be executed after a state change.
+ *
+ * For detailed description of the interface members, see the {@link StateMachineConfig} docs.
+ *
+ * @docsCategory payment
+ */
+export interface RefundProcess<State extends keyof CustomRefundStates | string> extends InjectableStrategy {
+    transitions?: Transitions<State, State | RefundState> & Partial<Transitions<RefundState | State>>;
+    onTransitionStart?: OnTransitionStartFn<State | RefundState, RefundTransitionData>;
+    onTransitionEnd?: OnTransitionEndFn<State | RefundState, RefundTransitionData>;
+    onTransitionError?: OnTransitionErrorFn<State | RefundState>;
+}
+/**
+ * @description
+ * Used to define extensions to or modifications of the default refund process.
+ *
+ * For detailed description of the interface members, see the {@link StateMachineConfig} docs.
+ *
+ * @deprecated Use RefundProcess
+ */
+export interface CustomRefundProcess<State extends keyof CustomRefundStates | string> extends RefundProcess<State> {
+}

package/dist/config/refund/refund-process.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=refund-process.js.map

package/dist/config/refund/refund-process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refund-process.js","sourceRoot":"","sources":["../../../src/config/refund/refund-process.ts"],"names":[],"mappings":""}

package/dist/config/session-cache/in-memory-session-cache-strategy.d.ts

@@ -0,0 +1,24 @@
+import { CachedSession, SessionCacheStrategy } from "./session-cache-strategy";
+/**
+ * @description
+ * Caches session in memory, using a LRU cache implementation. Not suitable for
+ * multi-server setups since the cache will be local to each instance, reducing
+ * its effectiveness. By default the cache has a size of 1000, meaning that after
+ * 1000 sessions have been cached, any new sessions will cause the least-recently-used
+ * session to be evicted (removed) from the cache.
+ *
+ * The cache size can be configured by passing a different number to the constructor
+ * function.
+ *
+ * @docsCategory auth
+ */
+export declare class InMemorySessionCacheStrategy implements SessionCacheStrategy {
+    private readonly cache;
+    private readonly cacheSize;
+    constructor(cacheSize?: number);
+    delete(sessionToken: string): void;
+    get(sessionToken: string): CachedSession | undefined;
+    set(session: CachedSession): void;
+    clear(): void;
+    private first;
+}

package/dist/config/session-cache/in-memory-session-cache-strategy.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySessionCacheStrategy = void 0;
+/**
+ * @description
+ * Caches session in memory, using a LRU cache implementation. Not suitable for
+ * multi-server setups since the cache will be local to each instance, reducing
+ * its effectiveness. By default the cache has a size of 1000, meaning that after
+ * 1000 sessions have been cached, any new sessions will cause the least-recently-used
+ * session to be evicted (removed) from the cache.
+ *
+ * The cache size can be configured by passing a different number to the constructor
+ * function.
+ *
+ * @docsCategory auth
+ */
+class InMemorySessionCacheStrategy {
+    constructor(cacheSize) {
+        this.cache = new Map();
+        this.cacheSize = 1000;
+        if (cacheSize != null) {
+            if (cacheSize < 1) {
+                throw new Error("cacheSize must be a positive integer");
+            }
+            this.cacheSize = Math.round(cacheSize);
+        }
+    }
+    delete(sessionToken) {
+        this.cache.delete(sessionToken);
+    }
+    get(sessionToken) {
+        const item = this.cache.get(sessionToken);
+        if (item) {
+            // refresh key
+            this.cache.delete(sessionToken);
+            this.cache.set(sessionToken, item);
+        }
+        return item;
+    }
+    set(session) {
+        this.cache.set(session.token, session);
+        if (this.cache.has(session.token)) {
+            // refresh key
+            this.cache.delete(session.token);
+        }
+        else if (this.cache.size === this.cacheSize) {
+            // evict oldest
+            this.cache.delete(this.first());
+        }
+        this.cache.set(session.token, session);
+    }
+    clear() {
+        this.cache.clear();
+    }
+    first() {
+        return this.cache.keys().next().value;
+    }
+}
+exports.InMemorySessionCacheStrategy = InMemorySessionCacheStrategy;
+//# sourceMappingURL=in-memory-session-cache-strategy.js.map

package/dist/config/session-cache/in-memory-session-cache-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-session-cache-strategy.js","sourceRoot":"","sources":["../../../src/config/session-cache/in-memory-session-cache-strategy.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;GAYG;AACH,MAAa,4BAA4B;IAIvC,YAAY,SAAkB;QAHb,UAAK,GAAG,IAAI,GAAG,EAAyB,CAAC;QACzC,cAAS,GAAW,IAAI,CAAC;QAGxC,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;YACtB,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;gBAClB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YAC1D,CAAC;YACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IAED,MAAM,CAAC,YAAoB;QACzB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAClC,CAAC;IAED,GAAG,CAAC,YAAoB;QACtB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC1C,IAAI,IAAI,EAAE,CAAC;YACT,cAAc;YACd,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YAChC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,GAAG,CAAC,OAAsB;QACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAEvC,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAClC,cAAc;YACd,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC;aAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YAC9C,eAAe;YACf,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;QAClC,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAEO,KAAK;QACX,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;IACxC,CAAC;CACF;AA/CD,oEA+CC"}

package/dist/config/session-cache/noop-session-cache-strategy.d.ts

@@ -0,0 +1,14 @@
+import { CachedSession, SessionCacheStrategy } from "./session-cache-strategy";
+/**
+ * @description
+ * A cache that doesn't cache. The cache lookup will miss every time
+ * so the session will always be taken from the database.
+ *
+ * @docsCategory auth
+ */
+export declare class NoopSessionCacheStrategy implements SessionCacheStrategy {
+    clear(): undefined;
+    delete(sessionToken: string): undefined;
+    get(sessionToken: string): undefined;
+    set(session: CachedSession): undefined;
+}

package/dist/config/session-cache/noop-session-cache-strategy.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopSessionCacheStrategy = void 0;
+/**
+ * @description
+ * A cache that doesn't cache. The cache lookup will miss every time
+ * so the session will always be taken from the database.
+ *
+ * @docsCategory auth
+ */
+class NoopSessionCacheStrategy {
+    clear() {
+        return undefined;
+    }
+    delete(sessionToken) {
+        return undefined;
+    }
+    get(sessionToken) {
+        return undefined;
+    }
+    set(session) {
+        return undefined;
+    }
+}
+exports.NoopSessionCacheStrategy = NoopSessionCacheStrategy;
+//# sourceMappingURL=noop-session-cache-strategy.js.map

package/dist/config/session-cache/noop-session-cache-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop-session-cache-strategy.js","sourceRoot":"","sources":["../../../src/config/session-cache/noop-session-cache-strategy.ts"],"names":[],"mappings":";;;AAEA;;;;;;GAMG;AACH,MAAa,wBAAwB;IACnC,KAAK;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,CAAC,YAAoB;QACzB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,GAAG,CAAC,YAAoB;QACtB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,GAAG,CAAC,OAAsB;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AAhBD,4DAgBC"}

package/dist/config/session-cache/session-cache-strategy.d.ts

@@ -0,0 +1,174 @@
+import { ID } from "@deenruv/common/lib/shared-types";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { UserChannelPermissions } from "../../service/helpers/utils/get-user-channels-permissions";
+/**
+ * @description
+ * A simplified representation of the User associated with the
+ * current Session.
+ *
+ * @docsCategory auth
+ * @docsPage SessionCacheStrategy
+ */
+export type CachedSessionUser = {
+    id: ID;
+    identifier: string;
+    verified: boolean;
+    channelPermissions: UserChannelPermissions[];
+};
+/**
+ * @description
+ * A simplified representation of a Session which is easy to
+ * store.
+ *
+ * @docsCategory auth
+ * @docsPage SessionCacheStrategy
+ */
+export type CachedSession = {
+    /**
+     * @description
+     * The timestamp after which this cache entry is considered stale and
+     * a fresh copy of the data will be set. Based on the `sessionCacheTTL`
+     * option.
+     */
+    cacheExpiry: number;
+    id: ID;
+    token: string;
+    expires: Date;
+    activeOrderId?: ID;
+    authenticationStrategy?: string;
+    user?: CachedSessionUser;
+    activeChannelId?: ID;
+};
+/**
+ * @description
+ * This strategy defines how sessions get cached. Since most requests will need the Session
+ * object for permissions data, it can become a bottleneck to go to the database and do a multi-join
+ * SQL query each time. Therefore, we cache the session data only perform the SQL query once and upon
+ * invalidation of the cache.
+ *
+ * The Deenruv default is to use a the {@link InMemorySessionCacheStrategy}, which is fast and suitable for
+ * single-instance deployments. However, for multi-instance deployments (horizontally scaled, serverless etc.),
+ * you will need to define a custom strategy that stores the session cache in a shared data store, such as in the
+ * DB or in Redis.
+ *
+ * :::info
+ *
+ * This is configured via the `authOptions.sessionCacheStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * Here's an example implementation using Redis. To use this, you need to add the
+ * [ioredis package](https://www.npmjs.com/package/ioredis) as a dependency.
+ *
+ * @example
+ * ```ts
+ * import { CachedSession, Logger, SessionCacheStrategy, DeenruvPlugin } from '\@deenruv/core';
+ * import { Redis, RedisOptions } from 'ioredis';
+ *
+ * export interface RedisSessionCachePluginOptions {
+ *   namespace?: string;
+ *   redisOptions?: RedisOptions;
+ * }
+ * const loggerCtx = 'RedisSessionCacheStrategy';
+ * const DEFAULT_NAMESPACE = 'deenruv-session-cache';
+ * const DEFAULT_TTL = 86400;
+ *
+ * export class RedisSessionCacheStrategy implements SessionCacheStrategy {
+ *   private client: Redis;
+ *   constructor(private options: RedisSessionCachePluginOptions) {}
+ *
+ *   init() {
+ *     this.client = new Redis(this.options.redisOptions as RedisOptions);
+ *     this.client.on('error', err => Logger.error(err.message, loggerCtx, err.stack));
+ *   }
+ *
+ *   async destroy() {
+ *     await this.client.quit();
+ *   }
+ *
+ *   async get(sessionToken: string): Promise<CachedSession | undefined> {
+ *     try {
+ *       const retrieved = await this.client.get(this.namespace(sessionToken));
+ *       if (retrieved) {
+ *         try {
+ *           return JSON.parse(retrieved);
+ *         } catch (e: any) {
+ *           Logger.error(`Could not parse cached session data: ${e.message}`, loggerCtx);
+ *         }
+ *       }
+ *     } catch (e: any) {
+ *       Logger.error(`Could not get cached session: ${e.message}`, loggerCtx);
+ *     }
+ *   }
+ *
+ *   async set(session: CachedSession) {
+ *     try {
+ *       await this.client.set(this.namespace(session.token), JSON.stringify(session), 'EX', DEFAULT_TTL);
+ *     } catch (e: any) {
+ *       Logger.error(`Could not set cached session: ${e.message}`, loggerCtx);
+ *     }
+ *   }
+ *
+ *   async delete(sessionToken: string) {
+ *     try {
+ *       await this.client.del(this.namespace(sessionToken));
+ *     } catch (e: any) {
+ *       Logger.error(`Could not delete cached session: ${e.message}`, loggerCtx);
+ *     }
+ *   }
+ *
+ *   clear() {
+ *     // not implemented
+ *   }
+ *
+ *   private namespace(key: string) {
+ *     return `${this.options.namespace ?? DEFAULT_NAMESPACE}:${key}`;
+ *   }
+ * }
+ *
+ * \@DeenruvPlugin({
+ *   configuration: config => {
+ *     config.authOptions.sessionCacheStrategy = new RedisSessionCacheStrategy(
+ *       RedisSessionCachePlugin.options,
+ *     );
+ *     return config;
+ *   },
+ * })
+ * export class RedisSessionCachePlugin {
+ *   static options: RedisSessionCachePluginOptions;
+ *   static init(options: RedisSessionCachePluginOptions) {
+ *     this.options = options;
+ *     return this;
+ *   }
+ * }
+ * ```
+ *
+ * @docsCategory auth
+ * @docsPage SessionCacheStrategy
+ * @docsWeight 0
+ */
+export interface SessionCacheStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * Store the session in the cache. When caching a session, the data
+     * should not be modified apart from performing any transforms needed to
+     * get it into a state to be stored, e.g. JSON.stringify().
+     */
+    set(session: CachedSession): void | Promise<void>;
+    /**
+     * @description
+     * Retrieve the session from the cache
+     */
+    get(sessionToken: string): CachedSession | undefined | Promise<CachedSession | undefined>;
+    /**
+     * @description
+     * Delete a session from the cache
+     */
+    delete(sessionToken: string): void | Promise<void>;
+    /**
+     * @description
+     * Clear the entire cache
+     */
+    clear(): void | Promise<void>;
+}

package/dist/config/session-cache/session-cache-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=session-cache-strategy.js.map

package/dist/config/session-cache/session-cache-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-cache-strategy.js","sourceRoot":"","sources":["../../../src/config/session-cache/session-cache-strategy.ts"],"names":[],"mappings":""}