@scayle/storefront-core 7.22.1

package/dist/cache/cached.d.ts

@@ -0,0 +1,24 @@
+import { Log } from '../utils';
+import { Cache as CacheInterface } from './cache';
+export type CacheOptions = Partial<{
+    ttl: number;
+    cacheKey: string;
+    cacheKeyPrefix: string;
+    timeout: number;
+}>;
+type Fn<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<TResult>;
+export declare class Cached {
+    private cache;
+    private log;
+    private prefix;
+    private enabled;
+    constructor(cache: CacheInterface, log: Log, prefix?: string | number, enabled?: boolean);
+    get isCacheEnabled(): boolean | undefined;
+    execute<TArgs extends unknown[], TResult>(fn: Fn<TArgs, TResult>, options?: CacheOptions): Awaited<Fn<TArgs, TResult>>;
+    private getCacheValue;
+    private setCacheValue;
+    private createCacheKey;
+    private handleError;
+}
+export type { Cache as CacheInterface } from './cache';
+export type CachedType = Cached['execute'];

package/dist/cache/cached.mjs

@@ -0,0 +1,92 @@
+import { tryit } from "radash";
+import { autobind } from "../helpers/autobind.mjs";
+import { timeout } from "../utils/index.mjs";
+import { sha256 } from "../utils/hash.mjs";
+import { CACHE_TIMEOUT } from "../constants/index.mjs";
+const CACHE_NOT_INITIALIZED_MSG = "Cache is not initialized";
+export class Cached {
+  cache;
+  log;
+  prefix;
+  enabled;
+  constructor(cache, log, prefix = "", enabled = process.env.AY_CACHE_DISABLED !== "true") {
+    if (!cache) {
+      log.error(CACHE_NOT_INITIALIZED_MSG);
+      throw new Error(CACHE_NOT_INITIALIZED_MSG);
+    }
+    this.cache = cache;
+    this.log = log.space("cached.init");
+    this.prefix = prefix;
+    this.enabled = enabled;
+    autobind(this);
+  }
+  get isCacheEnabled() {
+    return this.enabled;
+  }
+  execute(fn, options) {
+    return async (...args) => {
+      const prefix = options?.cacheKeyPrefix ?? fn.name;
+      const params = [...args, this?.prefix];
+      const cacheKey = options?.cacheKey ?? await this.createCacheKey(params, prefix);
+      const [cacheGetError, cachedResponse] = await tryit(this.getCacheValue)(
+        cacheKey,
+        options
+      );
+      if (cachedResponse) {
+        return cachedResponse;
+      }
+      if (cacheGetError) {
+        this.handleError(cacheGetError, false);
+      }
+      const [error, response] = await tryit(fn)(...args);
+      if (error) {
+        this.handleError(error);
+      }
+      if (cacheGetError) {
+        return response;
+      }
+      const [cacheSetError] = await tryit(this.setCacheValue)(
+        cacheKey,
+        response,
+        options
+      );
+      if (cacheSetError) {
+        this.handleError(cacheSetError);
+      }
+      return response;
+    };
+  }
+  async getCacheValue(cacheKey, options) {
+    if (!this.isCacheEnabled) {
+      return;
+    }
+    const data = await timeout(
+      options?.timeout ?? CACHE_TIMEOUT,
+      this.cache.get(cacheKey)
+    );
+    if (data !== null) {
+      return data;
+    }
+  }
+  async setCacheValue(cacheKey, value, options) {
+    if (!this.isCacheEnabled) {
+      return;
+    }
+    const ttl = options?.ttl || 60 * 60;
+    if (ttl) {
+      await timeout(CACHE_TIMEOUT, this.cache.set(cacheKey, value, ttl));
+    }
+  }
+  async createCacheKey(params, prefix = "") {
+    return [prefix, await sha256(JSON.stringify(params))].join(":");
+  }
+  handleError(error, shouldThrow = true) {
+    if (error.message === "timeout") {
+      return this.log.error("Cache timeout");
+    }
+    this.log.error(error);
+    if (shouldThrow) {
+      throw error;
+    }
+  }
+}

package/dist/cache/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _cache = require("./cache.cjs");
+Object.keys(_cache).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cache[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cache[key];
+    }
+  });
+});
+var _cached = require("./cached.cjs");
+Object.keys(_cached).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _cached[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cached[key];
+    }
+  });
+});
+var _types = require("./types.cjs");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});

package/dist/cache/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cache';
+export * from './cached';
+export * from './types';

package/dist/cache/index.mjs

@@ -0,0 +1,3 @@
+export * from "./cache.mjs";
+export * from "./cached.mjs";
+export * from "./types.mjs";

package/dist/cache/providers/redis.cjs

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createClient = exports.RedisCache = void 0;
+var _redis = require("redis");
+var _compression = require("../../utils/compression.cjs");
+const connections = {};
+const createClient = async (options, log) => {
+  log = log.space("redis.createClient");
+  const connectionIndex = [options.host, options.database].join("_");
+  let client;
+  if (connections[connectionIndex] !== void 0) {
+    client = connections[connectionIndex];
+  } else {
+    client = connections[connectionIndex] = (0, _redis.createClient)({
+      ...options,
+      ...(options && "username" in options && {
+        username: options.username
+      }),
+      socket: {
+        host: options.host,
+        port: options.port,
+        ...(options.sslTransit === true ? {
+          tls: true,
+          checkServerIdentity: () => void 0
+        } : {
+          tls: false
+        })
+      }
+    });
+    client.on("error", error => {
+      log.error("Redis connection error", error);
+    });
+    await client.connect();
+  }
+  return client;
+};
+exports.createClient = createClient;
+class RedisCache {
+  client;
+  prefix;
+  constructor(client, prefix = "") {
+    this.client = client;
+    this.prefix = prefix;
+  }
+  async get(key) {
+    const value = await this.client.get(this.getKey(key));
+    if (value === null) {
+      return null;
+    }
+    return this.deserialize(value);
+  }
+  async has(key) {
+    return (await this.client.exists(this.getKey(key))) !== 0;
+  }
+  async purgeTags(tags) {
+    await Promise.all(tags.map(tag => this.purgeTag(tag)));
+  }
+  async purgeTag(tag) {
+    const keys = await this.client.sMembers(this.getKey(`tag:${tag}`));
+    await this.client.del(keys);
+    await this.client.del(this.getKey(`tag:${tag}`));
+  }
+  async purgeKeys(keys) {
+    await this.client.del(keys);
+  }
+  async purgeAll() {
+    await this.client.flushDb();
+  }
+  async set(key, value, ttl, tags = []) {
+    const _value = await this.serialize(value);
+    await this.client.set(this.getKey(key), _value, {
+      EX: ttl
+    });
+    await Promise.all(tags.map(tag => this.addKeyToTag(tag, this.getKey(key))));
+  }
+  async addKeyToTag(tag, key) {
+    await this.client.sAdd(this.getKey(`tag:${tag}`), key);
+  }
+  getKey(key) {
+    return [this.prefix, key].join(":");
+  }
+  async deserialize(value) {
+    const data = await (0, _compression.decompress)(value);
+    return JSON.parse(data);
+  }
+  async serialize(value) {
+    const data = JSON.stringify(value);
+    return await (0, _compression.compress)(data);
+  }
+}
+exports.RedisCache = RedisCache;

package/dist/cache/providers/redis.d.ts

@@ -0,0 +1,28 @@
+import { RedisClientType } from 'redis';
+import { Log } from '../../utils';
+import { Cache as CacheInterface } from '../../cache/cache';
+export interface RedisOptions {
+    username?: string;
+    password?: string;
+    host?: string;
+    port?: number;
+    database?: number;
+    sslTransit?: boolean;
+}
+export declare const createClient: (options: RedisOptions, log: Log) => Promise<RedisClientType>;
+export declare class RedisCache implements CacheInterface {
+    client: RedisClientType;
+    prefix: string;
+    constructor(client: RedisClientType, prefix?: string);
+    get(key: string): Promise<any>;
+    has(key: string): Promise<boolean>;
+    purgeTags(tags: string[]): Promise<void>;
+    purgeTag(tag: string): Promise<void>;
+    purgeKeys(keys: string[]): Promise<void>;
+    purgeAll(): Promise<void>;
+    set(key: string, value: any, ttl: number, tags?: string[]): Promise<void>;
+    private addKeyToTag;
+    private getKey;
+    private deserialize;
+    private serialize;
+}

package/dist/cache/providers/redis.mjs

@@ -0,0 +1,86 @@
+import { createClient as createRedisClient } from "redis";
+import { compress, decompress } from "../../utils/compression.mjs";
+const connections = {};
+export const createClient = async (options, log) => {
+  log = log.space("redis.createClient");
+  const connectionIndex = [options.host, options.database].join("_");
+  let client;
+  if (connections[connectionIndex] !== void 0) {
+    client = connections[connectionIndex];
+  } else {
+    client = connections[connectionIndex] = createRedisClient({
+      ...options,
+      ...options && "username" in options && { username: options.username },
+      socket: {
+        host: options.host,
+        port: options.port,
+        ...options.sslTransit === true ? {
+          tls: true,
+          checkServerIdentity: () => void 0
+        } : {
+          tls: false
+        }
+      }
+    });
+    client.on("error", (error) => {
+      log.error("Redis connection error", error);
+    });
+    await client.connect();
+  }
+  return client;
+};
+export class RedisCache {
+  client;
+  prefix;
+  constructor(client, prefix = "") {
+    this.client = client;
+    this.prefix = prefix;
+  }
+  async get(key) {
+    const value = await this.client.get(this.getKey(key));
+    if (value === null) {
+      return null;
+    }
+    return this.deserialize(value);
+  }
+  async has(key) {
+    return await this.client.exists(this.getKey(key)) !== 0;
+  }
+  async purgeTags(tags) {
+    await Promise.all(tags.map((tag) => this.purgeTag(tag)));
+  }
+  async purgeTag(tag) {
+    const keys = await this.client.sMembers(this.getKey(`tag:${tag}`));
+    await this.client.del(keys);
+    await this.client.del(this.getKey(`tag:${tag}`));
+  }
+  async purgeKeys(keys) {
+    await this.client.del(keys);
+  }
+  async purgeAll() {
+    await this.client.flushDb();
+  }
+  async set(key, value, ttl, tags = []) {
+    const _value = await this.serialize(value);
+    await this.client.set(this.getKey(key), _value, {
+      EX: ttl
+    });
+    await Promise.all(
+      tags.map((tag) => this.addKeyToTag(tag, this.getKey(key)))
+    );
+  }
+  async addKeyToTag(tag, key) {
+    await this.client.sAdd(this.getKey(`tag:${tag}`), key);
+  }
+  getKey(key) {
+    return [this.prefix, key].join(":");
+  }
+  async deserialize(value) {
+    const data = await decompress(value);
+    return JSON.parse(data);
+  }
+  async serialize(value) {
+    const data = JSON.stringify(value);
+    return await compress(data);
+  }
+}

package/dist/cache/providers/unstorage.cjs

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnstorageCache = void 0;
+class UnstorageCache {
+  storage;
+  prefix;
+  constructor(storage, prefix = "") {
+    this.storage = storage;
+    this.prefix = prefix;
+  }
+  async get(key) {
+    const value = await this.storage.getItem(this.getKey(key));
+    if (value === null) {
+      return null;
+    }
+    return value;
+  }
+  async has(key) {
+    return await this.storage.hasItem(this.getKey(key));
+  }
+  async purgeTags(tags) {
+    await Promise.all(tags.map(tag => this.purgeTag(tag)));
+  }
+  async purgeTag(tag) {
+    const keys = await this.storage.getItem(this.getKey(`tag:${tag}`));
+    await this.purgeKeys(keys ?? []);
+    await this.storage.removeItem(this.getKey(`tag:${tag}`));
+  }
+  async purgeKeys(keys) {
+    await Promise.all(keys.map(k => this.storage.removeItem(k)));
+  }
+  async purgeAll() {
+    await this.storage.clear();
+  }
+  async set(key, value, ttl, tags = []) {
+    await this.storage.setItem(this.getKey(key), value, {
+      ttl
+    });
+    await Promise.all(tags.map(tag => this.addKeyToTag(tag, this.getKey(key))));
+  }
+  async addKeyToTag(tag, key) {
+    const keys = await this.storage.getItem(tag);
+    const set = new Set(keys ?? []);
+    set.add(key);
+    await this.storage.setItem(this.getKey(`tag:${tag}`), Array.from(set));
+  }
+  getKey(key) {
+    return [this.prefix, key].join(":");
+  }
+}
+exports.UnstorageCache = UnstorageCache;

package/dist/cache/providers/unstorage.d.ts

@@ -0,0 +1,16 @@
+import type { Storage } from 'unstorage';
+import { Cache as CacheInterface } from '../cache';
+export declare class UnstorageCache implements CacheInterface {
+    storage: Storage;
+    prefix: string;
+    constructor(storage: Storage, prefix?: string);
+    get(key: string): Promise<any | null>;
+    has(key: string): Promise<boolean>;
+    purgeTags(tags: string[]): Promise<void>;
+    purgeTag(tag: string): Promise<void>;
+    purgeKeys(keys: string[]): Promise<void>;
+    purgeAll(): Promise<void>;
+    set(key: string, value: any, ttl: number, tags?: string[]): Promise<void>;
+    private addKeyToTag;
+    private getKey;
+}

package/dist/cache/providers/unstorage.mjs

@@ -0,0 +1,49 @@
+export class UnstorageCache {
+  storage;
+  prefix;
+  constructor(storage, prefix = "") {
+    this.storage = storage;
+    this.prefix = prefix;
+  }
+  async get(key) {
+    const value = await this.storage.getItem(this.getKey(key));
+    if (value === null) {
+      return null;
+    }
+    return value;
+  }
+  async has(key) {
+    return await this.storage.hasItem(this.getKey(key));
+  }
+  async purgeTags(tags) {
+    await Promise.all(tags.map((tag) => this.purgeTag(tag)));
+  }
+  async purgeTag(tag) {
+    const keys = await this.storage.getItem(this.getKey(`tag:${tag}`));
+    await this.purgeKeys(keys ?? []);
+    await this.storage.removeItem(this.getKey(`tag:${tag}`));
+  }
+  async purgeKeys(keys) {
+    await Promise.all(keys.map((k) => this.storage.removeItem(k)));
+  }
+  async purgeAll() {
+    await this.storage.clear();
+  }
+  async set(key, value, ttl, tags = []) {
+    await this.storage.setItem(this.getKey(key), value, {
+      ttl
+    });
+    await Promise.all(
+      tags.map((tag) => this.addKeyToTag(tag, this.getKey(key)))
+    );
+  }
+  async addKeyToTag(tag, key) {
+    const keys = await this.storage.getItem(tag);
+    const set = new Set(keys ?? []);
+    set.add(key);
+    await this.storage.setItem(this.getKey(`tag:${tag}`), Array.from(set));
+  }
+  getKey(key) {
+    return [this.prefix, key].join(":");
+  }
+}

package/dist/cache/types.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CacheProvider = void 0;
+const CacheProvider = {
+  REDIS: "redis",
+  UNSTORAGE: "unstorage"
+};
+exports.CacheProvider = CacheProvider;

package/dist/cache/types.d.ts

@@ -0,0 +1,6 @@
+import { ValuesType } from 'utility-types';
+export declare const CacheProvider: {
+    readonly REDIS: "redis";
+    readonly UNSTORAGE: "unstorage";
+};
+export type CacheProvider = ValuesType<typeof CacheProvider> | null;

package/dist/cache/types.mjs

@@ -0,0 +1,4 @@
+export const CacheProvider = {
+  REDIS: "redis",
+  UNSTORAGE: "unstorage"
+};

package/dist/constants/basket.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExistingItemHandling = void 0;
+const ExistingItemHandling = {
+  KeepExisting: 0,
+  AddQuantityToExisting: 1,
+  ReplaceExisting: 2,
+  ReplaceExistingWithCombinedQuantity: 3
+};
+exports.ExistingItemHandling = ExistingItemHandling;

package/dist/constants/basket.d.ts

@@ -0,0 +1,8 @@
+import { ValuesType } from 'utility-types';
+export declare const ExistingItemHandling: {
+    readonly KeepExisting: 0;
+    readonly AddQuantityToExisting: 1;
+    readonly ReplaceExisting: 2;
+    readonly ReplaceExistingWithCombinedQuantity: 3;
+};
+export type ExistingItemHandling = ValuesType<typeof ExistingItemHandling>;

package/dist/constants/basket.mjs

@@ -0,0 +1,6 @@
+export const ExistingItemHandling = {
+  KeepExisting: 0,
+  AddQuantityToExisting: 1,
+  ReplaceExisting: 2,
+  ReplaceExistingWithCombinedQuantity: 3
+};

package/dist/constants/cache.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CACHE_TIMEOUT = void 0;
+const CACHE_TIMEOUT = 500;
+exports.CACHE_TIMEOUT = CACHE_TIMEOUT;

package/dist/constants/cache.d.ts

@@ -0,0 +1 @@
+export declare const CACHE_TIMEOUT = 500;

package/dist/constants/cache.mjs

@@ -0,0 +1 @@
+export const CACHE_TIMEOUT = 500;

package/dist/constants/hash.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HashAlgorithm = void 0;
+const HashAlgorithm = {
+  MD5: "md5",
+  SHA256: "sha256"
+};
+exports.HashAlgorithm = HashAlgorithm;

package/dist/constants/hash.d.ts

@@ -0,0 +1,6 @@
+import { ValuesType } from 'utility-types';
+export declare const HashAlgorithm: {
+    readonly MD5: "md5";
+    readonly SHA256: "sha256";
+};
+export type HashAlgorithm = ValuesType<typeof HashAlgorithm> | null;

package/dist/constants/hash.mjs

@@ -0,0 +1,4 @@
+export const HashAlgorithm = {
+  MD5: "md5",
+  SHA256: "sha256"
+};