@pisell/pisellos 2.3.72 → 2.3.73

package/lib/solution/UnifiedBookingSales/remoteOccupancyCache.d.ts

@@ -0,0 +1,49 @@
+import type { AvailabilityDateRange } from '../../modules/ResourcePlanner';
+type AvailabilityId = number | string;
+export declare class AvailabilityRemoteOccupancyCache {
+    private readonly maxCells;
+    private readonly cells;
+    private readonly resourceMeta;
+    private readonly resourceCellCounts;
+    constructor(maxCells?: number);
+    clear(): void;
+    read(params: {
+        scopeKey: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+    }): Record<string, any>[] | null;
+    hasCompleteCoverage(params: {
+        scopeKey: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+    }): boolean;
+    publish(params: {
+        scopeKey: string;
+        timezoneName: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+        rawResources: Record<string, any>[];
+        version: number;
+    }): void;
+    private buildResourceKey;
+    private buildCellKey;
+    private touchCell;
+    /**
+     * A response is one coherent resource snapshot for its requested range. If any overlapping day
+     * already contains a newer response, publishing only the older response's remaining days would
+     * let a cross-midnight event leak back into that newer day when ranges are recomposed.
+     */
+    private canPublishResourceRange;
+    /**
+     * A day cell stores the original event range so it can be reconstructed without losing server
+     * identity. When a newer adjacent-day response replaces that event, evict older neighbour cells
+     * whose event overlaps the refreshed range. The next wider read becomes a cache miss instead of
+     * reintroducing stale occupancy from the neighbour.
+     */
+    private invalidateAdjacentOverlappingCells;
+    private deleteCell;
+    private deleteResourceCells;
+    private writeResourceMeta;
+    private writeCell;
+}
+export {};

package/lib/solution/UnifiedBookingSales/remoteOccupancyCache.js

@@ -0,0 +1,376 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/UnifiedBookingSales/remoteOccupancyCache.ts
+var remoteOccupancyCache_exports = {};
+__export(remoteOccupancyCache_exports, {
+  AvailabilityRemoteOccupancyCache: () => AvailabilityRemoteOccupancyCache
+});
+module.exports = __toCommonJS(remoteOccupancyCache_exports);
+var import_lodash_es = require("lodash-es");
+var import_localClock = require("../../modules/ResourcePlanner/localClock");
+function uniqueIds(values) {
+  const result = /* @__PURE__ */ new Map();
+  values.forEach((value) => {
+    if (value === void 0 || value === null || value === "")
+      return;
+    result.set(String(value), value);
+  });
+  return Array.from(result.values());
+}
+function buildDateList(dateRange) {
+  if (!(dateRange == null ? void 0 : dateRange.startDate) || !(dateRange == null ? void 0 : dateRange.endDate))
+    return [];
+  try {
+    const startOrdinal = (0, import_localClock.dateOrdinalFromLocalDate)(dateRange.startDate);
+    const endOrdinal = (0, import_localClock.dateOrdinalFromLocalDate)(dateRange.endDate);
+    if (endOrdinal < startOrdinal)
+      return [];
+    const dates = [];
+    let cursor = (0, import_localClock.localDateToScalarStart)(dateRange.startDate);
+    for (let ordinal = startOrdinal; ordinal <= endOrdinal; ordinal += 1) {
+      dates.push((0, import_localClock.formatLocalDate)(cursor));
+      cursor = (0, import_localClock.addLocalCalendarDays)(cursor, 1);
+    }
+    return dates;
+  } catch {
+    return [];
+  }
+}
+function resolveResourceId(raw) {
+  const id = raw.resourceId ?? raw.resource_id ?? raw.id;
+  if (id === void 0 || id === null || id === "")
+    return null;
+  return id;
+}
+function getRawEventStartAt(rawEvent) {
+  const startAt = rawEvent.start_at ?? rawEvent.startAt ?? rawEvent.start_time ?? rawEvent.startTime;
+  return startAt ? String(startAt) : null;
+}
+function getRawEventEndAt(rawEvent) {
+  const endAt = rawEvent.end_at ?? rawEvent.endAt ?? rawEvent.end_time ?? rawEvent.endTime;
+  return endAt ? String(endAt) : null;
+}
+function parseEventScalar(value) {
+  return (0, import_localClock.localDateTimeToScalar)((0, import_localClock.parseLocalDateTime)(value));
+}
+function buildEventIdentity(resourceId, rawEvent) {
+  var _a, _b;
+  const scheduleEventId = rawEvent.schedule_event_id ?? rawEvent.scheduleEventId;
+  if (scheduleEventId !== void 0 && scheduleEventId !== null && scheduleEventId !== "") {
+    return `scheduleEvent:${String(resourceId)}:${String(scheduleEventId)}`;
+  }
+  const bookingUid = rawEvent.booking_uid ?? rawEvent.bookingUid ?? ((_a = rawEvent.metadata) == null ? void 0 : _a.unique_identification_number);
+  if (bookingUid !== void 0 && bookingUid !== null && bookingUid !== "") {
+    return `bookingUid:${String(resourceId)}:${String(bookingUid)}`;
+  }
+  const productUid = rawEvent.product_uid ?? rawEvent.productUid ?? ((_b = rawEvent.metadata) == null ? void 0 : _b.product_uid);
+  if (productUid !== void 0 && productUid !== null && productUid !== "") {
+    return `productUid:${String(resourceId)}:${String(productUid)}`;
+  }
+  return [
+    "range",
+    String(resourceId),
+    getRawEventStartAt(rawEvent) || "",
+    getRawEventEndAt(rawEvent) || ""
+  ].join(":");
+}
+function bucketEventDates(params) {
+  const startAt = getRawEventStartAt(params.rawEvent);
+  const endAt = getRawEventEndAt(params.rawEvent);
+  if (!startAt || !endAt)
+    return [];
+  try {
+    const startScalar = parseEventScalar(startAt);
+    const endScalar = parseEventScalar(endAt);
+    if (endScalar <= startScalar)
+      return [];
+    const endInclusiveScalar = endScalar - 1e3;
+    const startDate = (0, import_localClock.formatLocalDate)(startScalar);
+    const endDate = (0, import_localClock.formatLocalDate)(endInclusiveScalar);
+    const startOrdinal = (0, import_localClock.dateOrdinalFromLocalDate)(startDate);
+    const endOrdinal = (0, import_localClock.dateOrdinalFromLocalDate)(endDate);
+    if (endOrdinal < startOrdinal)
+      return [];
+    const dates = [];
+    let cursorDate = startDate;
+    for (let ordinal = startOrdinal; ordinal <= endOrdinal; ordinal += 1) {
+      if (params.requestedDates.has(cursorDate)) {
+        dates.push(cursorDate);
+      }
+      cursorDate = (0, import_localClock.nextDate)(cursorDate);
+    }
+    return dates;
+  } catch {
+    return [];
+  }
+}
+function sortEventList(events) {
+  return [...events].sort((left, right) => {
+    const leftStart = getRawEventStartAt(left) || "";
+    const rightStart = getRawEventStartAt(right) || "";
+    if (leftStart !== rightStart)
+      return leftStart.localeCompare(rightStart);
+    const leftEnd = getRawEventEndAt(left) || "";
+    const rightEnd = getRawEventEndAt(right) || "";
+    if (leftEnd !== rightEnd)
+      return leftEnd.localeCompare(rightEnd);
+    return buildEventIdentity(left.resource_id ?? left.resourceId ?? "", left).localeCompare(buildEventIdentity(right.resource_id ?? right.resourceId ?? "", right));
+  });
+}
+var AvailabilityRemoteOccupancyCache = class {
+  constructor(maxCells = 4096) {
+    this.cells = /* @__PURE__ */ new Map();
+    this.resourceMeta = /* @__PURE__ */ new Map();
+    this.resourceCellCounts = /* @__PURE__ */ new Map();
+    this.maxCells = maxCells;
+  }
+  clear() {
+    this.cells.clear();
+    this.resourceMeta.clear();
+    this.resourceCellCounts.clear();
+  }
+  read(params) {
+    const requestedResourceIds = uniqueIds(params.resourceIds);
+    const requestedDates = buildDateList(params.dateRange);
+    if (requestedResourceIds.length === 0 || requestedDates.length === 0)
+      return [];
+    const resources = [];
+    for (const resourceId of requestedResourceIds) {
+      const resourceKey = this.buildResourceKey(params.scopeKey, resourceId);
+      const eventList = /* @__PURE__ */ new Map();
+      for (const date of requestedDates) {
+        const cellKey = this.buildCellKey(resourceKey, date);
+        const cell = this.touchCell(cellKey);
+        if (!cell)
+          return null;
+        cell.eventList.forEach((rawEvent) => {
+          eventList.set(buildEventIdentity(resourceId, rawEvent), (0, import_lodash_es.cloneDeep)(rawEvent));
+        });
+      }
+      const metadataEntry = this.resourceMeta.get(resourceKey);
+      if (!metadataEntry)
+        return null;
+      if (metadataEntry.status === "absent")
+        continue;
+      if (!metadataEntry.metadata)
+        return null;
+      resources.push({
+        ...(0, import_lodash_es.cloneDeep)(metadataEntry.metadata),
+        event_list: sortEventList(Array.from(eventList.values()))
+      });
+    }
+    return resources;
+  }
+  hasCompleteCoverage(params) {
+    const requestedResourceIds = uniqueIds(params.resourceIds);
+    const requestedDates = buildDateList(params.dateRange);
+    if (requestedResourceIds.length === 0 || requestedDates.length === 0)
+      return true;
+    for (const resourceId of requestedResourceIds) {
+      const resourceKey = this.buildResourceKey(params.scopeKey, resourceId);
+      for (const date of requestedDates) {
+        const cell = this.cells.get(this.buildCellKey(resourceKey, date));
+        if (!cell)
+          return false;
+      }
+    }
+    return true;
+  }
+  publish(params) {
+    const requestedResourceIds = uniqueIds(params.resourceIds);
+    const requestedDates = buildDateList(params.dateRange);
+    if (requestedResourceIds.length === 0 || requestedDates.length === 0)
+      return;
+    const requestedDateSet = new Set(requestedDates);
+    const publishedAt = Date.now();
+    const requestedResourceKeyById = new Map(
+      requestedResourceIds.map((resourceId) => [
+        String(resourceId),
+        this.buildResourceKey(params.scopeKey, resourceId)
+      ])
+    );
+    const rawResourceById = /* @__PURE__ */ new Map();
+    (params.rawResources || []).forEach((rawResource) => {
+      const resourceId = resolveResourceId(rawResource);
+      if (resourceId !== null && requestedResourceKeyById.has(String(resourceId))) {
+        rawResourceById.set(String(resourceId), rawResource);
+      }
+    });
+    requestedResourceIds.forEach((resourceId) => {
+      const resourceKey = requestedResourceKeyById.get(String(resourceId));
+      if (!resourceKey)
+        return;
+      if (!this.canPublishResourceRange(resourceKey, requestedDates, params.version))
+        return;
+      const rawResource = rawResourceById.get(String(resourceId));
+      const nextStatus = rawResource ? "present" : "absent";
+      const currentMetadata = this.resourceMeta.get(resourceKey);
+      if (currentMetadata && currentMetadata.version <= params.version && currentMetadata.status !== nextStatus) {
+        this.deleteResourceCells(resourceKey);
+      }
+      this.invalidateAdjacentOverlappingCells({
+        resourceKey,
+        requestedDates: requestedDateSet,
+        timezoneName: params.timezoneName
+      });
+      const metadata = rawResource ? (({ event_list: _eventList, ...rest }) => rest)(rawResource) : void 0;
+      this.writeResourceMeta(resourceKey, nextStatus, metadata, params.version);
+      const eventsByDate = /* @__PURE__ */ new Map();
+      requestedDates.forEach((date) => {
+        eventsByDate.set(date, /* @__PURE__ */ new Map());
+      });
+      const eventList = Array.isArray(rawResource == null ? void 0 : rawResource.event_list) ? rawResource.event_list : [];
+      eventList.forEach((event) => {
+        const rawEvent = (0, import_lodash_es.cloneDeep)(event);
+        const identity = buildEventIdentity(resourceId, rawEvent);
+        bucketEventDates({
+          rawEvent,
+          timezoneName: params.timezoneName,
+          requestedDates: requestedDateSet
+        }).forEach((date) => {
+          var _a;
+          (_a = eventsByDate.get(date)) == null ? void 0 : _a.set(identity, rawEvent);
+        });
+      });
+      requestedDates.forEach((date) => {
+        var _a;
+        this.writeCell({
+          key: this.buildCellKey(resourceKey, date),
+          resourceKey,
+          version: params.version,
+          eventList: sortEventList(Array.from(((_a = eventsByDate.get(date)) == null ? void 0 : _a.values()) || [])),
+          fetchedAt: publishedAt,
+          lastAccessedAt: publishedAt
+        });
+      });
+    });
+  }
+  buildResourceKey(scopeKey, resourceId) {
+    return `${scopeKey}:${String(resourceId)}`;
+  }
+  buildCellKey(resourceKey, date) {
+    return `${resourceKey}:${date}`;
+  }
+  touchCell(cellKey) {
+    const entry = this.cells.get(cellKey);
+    if (!entry)
+      return null;
+    entry.lastAccessedAt = Date.now();
+    this.cells.delete(cellKey);
+    this.cells.set(cellKey, entry);
+    return entry;
+  }
+  /**
+   * A response is one coherent resource snapshot for its requested range. If any overlapping day
+   * already contains a newer response, publishing only the older response's remaining days would
+   * let a cross-midnight event leak back into that newer day when ranges are recomposed.
+   */
+  canPublishResourceRange(resourceKey, requestedDates, version) {
+    const metadata = this.resourceMeta.get(resourceKey);
+    if (metadata && metadata.version > version)
+      return false;
+    return requestedDates.every((date) => {
+      const current = this.cells.get(this.buildCellKey(resourceKey, date));
+      return !current || current.version <= version;
+    });
+  }
+  /**
+   * A day cell stores the original event range so it can be reconstructed without losing server
+   * identity. When a newer adjacent-day response replaces that event, evict older neighbour cells
+   * whose event overlaps the refreshed range. The next wider read becomes a cache miss instead of
+   * reintroducing stale occupancy from the neighbour.
+   */
+  invalidateAdjacentOverlappingCells(params) {
+    const keysToDelete = [];
+    this.cells.forEach((cell, cellKey) => {
+      if (cell.resourceKey !== params.resourceKey)
+        return;
+      const cellDate = cellKey.slice(cell.resourceKey.length + 1);
+      if (params.requestedDates.has(cellDate))
+        return;
+      const overlapsRequestedDate = cell.eventList.some((rawEvent) => bucketEventDates({
+        rawEvent,
+        timezoneName: params.timezoneName,
+        requestedDates: params.requestedDates
+      }).length > 0);
+      if (overlapsRequestedDate)
+        keysToDelete.push(cellKey);
+    });
+    keysToDelete.forEach((cellKey) => this.deleteCell(cellKey));
+  }
+  deleteCell(cellKey) {
+    const entry = this.cells.get(cellKey);
+    if (!entry)
+      return;
+    this.cells.delete(cellKey);
+    const nextCount = (this.resourceCellCounts.get(entry.resourceKey) || 1) - 1;
+    if (nextCount <= 0) {
+      this.resourceCellCounts.delete(entry.resourceKey);
+      this.resourceMeta.delete(entry.resourceKey);
+      return;
+    }
+    this.resourceCellCounts.set(entry.resourceKey, nextCount);
+  }
+  deleteResourceCells(resourceKey) {
+    const keysToDelete = [];
+    this.cells.forEach((cell, cellKey) => {
+      if (cell.resourceKey === resourceKey)
+        keysToDelete.push(cellKey);
+    });
+    keysToDelete.forEach((cellKey) => this.deleteCell(cellKey));
+  }
+  writeResourceMeta(resourceKey, status, metadata, version) {
+    const current = this.resourceMeta.get(resourceKey);
+    if (current && current.version > version)
+      return;
+    this.resourceMeta.set(resourceKey, {
+      version,
+      status,
+      metadata: metadata ? (0, import_lodash_es.cloneDeep)(metadata) : void 0
+    });
+  }
+  writeCell(entry) {
+    const current = this.cells.get(entry.key);
+    if (current && current.version > entry.version)
+      return;
+    if (!current) {
+      this.resourceCellCounts.set(
+        entry.resourceKey,
+        (this.resourceCellCounts.get(entry.resourceKey) || 0) + 1
+      );
+    } else {
+      this.cells.delete(entry.key);
+    }
+    this.cells.set(entry.key, {
+      ...entry,
+      eventList: (0, import_lodash_es.cloneDeep)(entry.eventList)
+    });
+    while (this.cells.size > this.maxCells) {
+      const oldest = this.cells.entries().next().value;
+      if (!oldest)
+        break;
+      const [oldestKey] = oldest;
+      this.deleteCell(oldestKey);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AvailabilityRemoteOccupancyCache
+});