@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

package/dist/runtime/resources/resources-manager.js

@@ -0,0 +1,463 @@
+import { computed, nextTick, reactive, ref, watch } from "vue";
+import { set, unset, mergeWith, isArray } from "lodash-es";
+import { createConfirmDialog } from "vuejs-confirm-dialog";
+import { DateTime } from "luxon";
+import {
+  CwaResourceTypes,
+  getPublishedResourceIri,
+  getPublishedResourceState,
+  getResourceTypeFromIri
+} from "./resource-utils.js";
+import { NEW_RESOURCE_IRI } from "#cwa/runtime/storage/stores/resources/state";
+import ConfirmDialog from "#cwa/runtime/templates/components/core/ConfirmDialog.vue";
+export class ResourcesManager {
+  constructor(cwaFetch, resourcesStoreDefinition, fetchStatusManager, errorStoreDefinition, fetcher, admin, resources) {
+    this.fetcher = fetcher;
+    this.admin = admin;
+    this.resources = resources;
+    this.cwaFetch = cwaFetch;
+    this.resourcesStoreDefinition = resourcesStoreDefinition;
+    this.fetchStatusManager = fetchStatusManager;
+    this.errorStoreDefinition = errorStoreDefinition;
+    watch(this.reqCount, (newValue) => {
+      if (newValue >= 1e4) {
+        this.reqCount.value = 0;
+      }
+    });
+  }
+  cwaFetch;
+  resourcesStoreDefinition;
+  fetchStatusManager;
+  errorStoreDefinition;
+  requestsInProgress = reactive({});
+  reqCount = ref(0);
+  _addResourceEvent = ref();
+  _requestCount;
+  mergeNewResources() {
+    return this.resourcesStore.mergeNewResources();
+  }
+  get requestCount() {
+    if (this._requestCount) {
+      return this._requestCount;
+    }
+    this._requestCount = computed(() => Object.values(this.requestsInProgress).reduce((count, reqs) => count + Object.values(reqs).length, 0));
+    return this._requestCount;
+  }
+  getWaitForRequestPromise(endpoint, property, source) {
+    const hasRequestConflict = () => {
+      if (!this.requestsInProgress.value) {
+        return false;
+      }
+      for (const req of Object.values(this.requestsInProgress)) {
+        if (req.event.endpoint === endpoint) {
+          if ("data" in req.event) {
+            return req.event.data?.[property] && (!source || req.event.source !== source);
+          }
+          return true;
+        }
+      }
+      return false;
+    };
+    return new Promise((resolve) => {
+      if (!hasRequestConflict()) {
+        resolve();
+        return;
+      }
+      const unwatch = watch(this.requestsInProgress, () => {
+        if (hasRequestConflict()) {
+          return;
+        }
+        unwatch();
+        resolve();
+      });
+    });
+  }
+  createResource(event) {
+    const args = [
+      event.endpoint,
+      { ...this.requestOptions("POST"), body: event.data }
+    ];
+    return this.doResourceRequest(event, args);
+  }
+  async confirmDelete() {
+    const alertData = {
+      title: "Delete this resource?",
+      content: "<p>Are you sure you want to permanently delete this resource?</p>"
+    };
+    const dialog = createConfirmDialog(ConfirmDialog);
+    const { isCanceled } = await dialog.reveal(alertData);
+    return !isCanceled;
+  }
+  getEndpointForIri(iri) {
+    const resource = this.resourcesStore.getResource(iri)?.data;
+    if (!resource) {
+      return iri;
+    }
+    const isDraft = getPublishedResourceState({ data: resource }) === false;
+    const postfix = isDraft ? "?published=false" : "?published=true";
+    return `${iri}${postfix}`;
+  }
+  async deleteResource(event) {
+    if (!await this.confirmDelete()) {
+      return false;
+    }
+    const args = [
+      this.getEndpointForIri(event.endpoint),
+      { ...this.requestOptions("DELETE") }
+    ];
+    return this.doResourceRequest(event, args);
+  }
+  removeResource(event) {
+    return this.resourcesStore.deleteResource(event);
+  }
+  async updateResource(event) {
+    const iri = (event.iri || event.endpoint).split("?")[0];
+    const currentResource = this.resourcesStore.getResource(iri)?.data;
+    const reqOps = {
+      ...this.requestOptions(event.data instanceof FormData ? "POST" : "PATCH"),
+      body: event.data
+    };
+    if (event.headers) {
+      reqOps.headers = event.headers;
+    }
+    const args = [
+      event.endpoint,
+      reqOps
+    ];
+    if (currentResource?._metadata.persisted === false) {
+      const newResource = mergeWith(currentResource, event.data, (a, b) => {
+        if (isArray(a)) {
+          return b.concat(a);
+        }
+      });
+      this.saveResource({
+        resource: newResource
+      });
+      return;
+    }
+    const currentIsDraft = getPublishedResourceState({ data: currentResource }) === false;
+    let isPublishing = false;
+    let existingLiveIri = null;
+    if (currentIsDraft) {
+      isPublishing = event.data.publishedAt <= DateTime.local().toUTC().toISO();
+      if (isPublishing) {
+        existingLiveIri = currentResource ? getPublishedResourceIri(currentResource) : null;
+        const currentLiveResource = existingLiveIri ? this.resourcesStore.getResource(existingLiveIri)?.data : void 0;
+        if (currentLiveResource) {
+          const updatingResourcePositions = currentLiveResource.componentPositions;
+          if (updatingResourcePositions) {
+            const existingRefreshEndpoints = event.refreshEndpoints || [];
+            event.refreshEndpoints = [...existingRefreshEndpoints, ...updatingResourcePositions];
+          }
+        }
+      }
+    }
+    const isPublishingAndOverwritingPreviousLiveResource = isPublishing && currentResource && existingLiveIri && existingLiveIri !== iri;
+    const postRequestFn = () => {
+      if (isPublishingAndOverwritingPreviousLiveResource) {
+        this.admin.emptyStack();
+      }
+    };
+    const postSaveFn = () => {
+      if (isPublishingAndOverwritingPreviousLiveResource) {
+        this.removeResource({ resource: event.endpoint, noCascade: true });
+      }
+    };
+    const resource = await this.doResourceRequest(event, args, postRequestFn, postSaveFn);
+    const responseId = resource?.["@id"];
+    if (responseId && responseId !== iri) {
+      this.admin.resourceStackManager.forcePublishedVersion.value = isPublishing ? void 0 : false;
+    }
+    return resource;
+  }
+  async doResourceRequest(event, args, postRequestFn, postSaveFn) {
+    const source = "source" in event ? event.source || "unknown" : "delete";
+    const id = ++this.reqCount.value;
+    const iri = (event.iri || event.endpoint).split("?")[0];
+    set(this.requestsInProgress, [source, id], { event, args });
+    this.errorStore.removeByEndpoint(args[0]);
+    try {
+      const resource = await this.cwaFetch.fetch(...args);
+      const refreshEndpoints = event.refreshEndpoints || [];
+      if (args[1].method === "POST") {
+        if (resource.componentPositions) {
+          refreshEndpoints.push(...resource.componentPositions);
+        }
+      }
+      if (refreshEndpoints.length) {
+        const fetchBathEvent = {
+          paths: refreshEndpoints,
+          shallowFetch: "noexist"
+        };
+        try {
+          await this.fetcher.fetchBatch(fetchBathEvent);
+        } catch (err) {
+          const fetchError = err;
+          if (fetchError?.statusCode !== 404) {
+            throw err;
+          }
+        }
+      }
+      if (postRequestFn) {
+        await postRequestFn(resource);
+      }
+      if (event.requestCompleteFn) {
+        await event.requestCompleteFn(resource);
+      }
+      if ("data" in event) {
+        this.saveResource({
+          resource
+        });
+      } else {
+        this.removeResource({
+          resource: iri
+        });
+      }
+      if (postSaveFn) {
+        await postSaveFn(resource);
+      }
+      if (event.saveCompleteFn) {
+        await event.saveCompleteFn(resource);
+      }
+      return resource;
+    } catch (err) {
+      this.errorStore.error(event, err);
+    } finally {
+      unset(this.requestsInProgress, [source, id]);
+    }
+  }
+  addError(error) {
+    this.errorStore.manual(error);
+  }
+  get errors() {
+    return this.errorStore.getErrors;
+  }
+  get hasErrors() {
+    return this.errorStore.hasErrors;
+  }
+  removeError(id) {
+    this.errorStore.removeById(id);
+  }
+  // @internal - just used in reset-password.ts - should be private and refactored for that use case
+  saveResource(event) {
+    return this.resourcesStore.saveResource(event);
+  }
+  requestOptions(method) {
+    const headers = {
+      accept: "application/ld+json,application/json"
+    };
+    if (this.fetchStatusManager.primaryFetchPath) {
+      headers.path = this.fetchStatusManager.primaryFetchPath;
+    }
+    headers["content-type"] = method === "PATCH" ? "application/merge-patch+json" : "application/ld+json";
+    return {
+      method,
+      headers
+    };
+  }
+  async initAddResource(targetIri, addAfter, resourceStack, pageDataProperty) {
+    const initEvent = {
+      targetIri,
+      addAfter
+    };
+    const findClosestResourceByType = (type) => {
+      for (const stackItem of resourceStack) {
+        if (getResourceTypeFromIri(stackItem.iri) === type) {
+          return stackItem.iri;
+        }
+      }
+    };
+    const findClosestPositionFromGroupEvent = (event) => {
+      const resource = this.resourcesStore.current.byId?.[event.targetIri];
+      const positions = resource?.data?.componentPositions;
+      if (!positions || !positions.length) {
+        return;
+      }
+      if (event.addAfter === true) {
+        return positions[positions.length - 1];
+      } else if (event.addAfter === false) {
+        return positions[0];
+      }
+    };
+    const findClosestPosition = (event) => {
+      if (getResourceTypeFromIri(event.targetIri) !== CwaResourceTypes.COMPONENT_GROUP) {
+        return findClosestResourceByType(CwaResourceTypes.COMPONENT_POSITION);
+      }
+      return findClosestPositionFromGroupEvent(event);
+    };
+    const closestPosition = findClosestPosition(initEvent);
+    const closestGroup = findClosestResourceByType(CwaResourceTypes.COMPONENT_GROUP);
+    if (!await this.confirmDiscardAddingResource()) {
+      return;
+    }
+    this._addResourceEvent.value = {
+      targetIri,
+      addAfter,
+      closest: {
+        position: closestPosition,
+        group: closestGroup
+      },
+      pageDataProperty
+    };
+  }
+  async setAddResourceEventResource(resourceType, endpoint, isPublishable, instantAdd, defaultData) {
+    if (!this._addResourceEvent.value) {
+      return;
+    }
+    this.resourcesStore.initNewResource(this._addResourceEvent.value, resourceType, endpoint, isPublishable, instantAdd, defaultData);
+    await nextTick(() => {
+      !instantAdd && this.admin.eventBus.emit("selectResource", NEW_RESOURCE_IRI);
+    });
+  }
+  clearAddResourceEventResource() {
+    this.resourcesStore.resetNewResource();
+  }
+  clearAddResource() {
+    this._addResourceEvent.value = void 0;
+    this.clearAddResourceEventResource();
+  }
+  get addResourceEvent() {
+    return this._addResourceEvent;
+  }
+  async confirmDiscardAddingResource() {
+    if (!this._addResourceEvent.value) {
+      return true;
+    }
+    const alertData = {
+      title: "Discard new resource?",
+      content: "<p>Are you sure you want to discard your new resource. It will NOT be saved.</p>"
+    };
+    const dialog = createConfirmDialog(ConfirmDialog);
+    const { isCanceled } = await dialog.reveal(alertData);
+    if (isCanceled) {
+      return false;
+    }
+    this.clearAddResource();
+    return true;
+  }
+  async addResourceAction(publish) {
+    const addEvent = this._addResourceEvent.value;
+    if (!addEvent || !this.resourcesStore.adding?.resource) {
+      throw new Error("Cannot add resource. No addResource event is present");
+    }
+    const resource = this.resourcesStore.getResource(this.resourcesStore.adding.resource)?.data;
+    if (!resource) {
+      throw new Error("Cannot add resource. No new resource exists in the store with data");
+    }
+    const addingMeta = resource._metadata.adding;
+    if (!addingMeta) {
+      throw new Error("Cannot add resource. There was no adding metadata on the new resource in the store.");
+    }
+    const refreshEndpoints = [];
+    if (addEvent.addAfter !== null) {
+      (() => {
+        addEvent.closest.group && refreshEndpoints.push(addEvent.closest.group);
+        const getPositionSortValue = () => {
+          let targetPosition;
+          if (getResourceTypeFromIri(addEvent.targetIri) === CwaResourceTypes.COMPONENT_GROUP) {
+            const groupResource = this.resourcesStore.getResource(addEvent.targetIri)?.data;
+            if (!groupResource?.componentPositions || groupResource?.componentPositions.length === 0) {
+              return 0;
+            }
+            targetPosition = addEvent.addAfter ? groupResource.componentPositions[groupResource.componentPositions.length - 1] : groupResource.componentPositions[0];
+          } else {
+            targetPosition = addEvent.closest.position;
+          }
+          if (!targetPosition) {
+            return 0;
+          }
+          const sortValue = this.resourcesStore.getResource(targetPosition)?.data?.sortValue;
+          return sortValue !== void 0 ? addEvent.addAfter ? sortValue + 1 : sortValue : 0;
+        };
+        const positionIri = this.resourcesStore.adding.position;
+        if (!positionIri) {
+          resource.sortValue = getPositionSortValue();
+          refreshEndpoints.push(...this.getRefreshPositions(this.resourcesStore.adding.resource));
+          return;
+        }
+        const positionData = this.resourcesStore.getResource(positionIri)?.data;
+        if (!positionData) {
+          throw new Error("Position resource being added not found");
+        }
+        const positionPostData = {
+          ...this.resourcesStore.getResource(positionIri)?.data,
+          "@id": void 0,
+          "@type": void 0,
+          "sortValue": getPositionSortValue()
+        };
+        resource.componentPositions = [
+          positionPostData
+        ];
+        refreshEndpoints.push(...this.getRefreshPositions(positionIri));
+      })();
+    } else if (!addEvent.pageDataProperty) {
+      const addingToIri = addEvent.targetIri;
+      if (getResourceTypeFromIri(addingToIri) !== CwaResourceTypes.COMPONENT_POSITION) {
+        throw new Error("Cannot add to arbitrary IRIs. Only to component positions.");
+      }
+      resource.componentPositions = [addingToIri];
+    }
+    if (publish !== void 0) {
+      resource.publishedAt = publish ? DateTime.local().toUTC().toISO() : null;
+    }
+    const postData = { ...resource, "@id": void 0, "@type": void 0 };
+    const requestCompleteFn = () => {
+      this.clearAddResource();
+    };
+    const newResource = await this.createResource({
+      endpoint: addingMeta.endpoint,
+      data: postData,
+      refreshEndpoints,
+      requestCompleteFn: () => {
+        this.clearAddResource();
+      }
+    });
+    if (newResource && addEvent.pageDataProperty) {
+      await this.updateResource({
+        endpoint: this.resources.pageDataIri.value,
+        data: { [addEvent.pageDataProperty]: newResource["@id"] },
+        refreshEndpoints: [addEvent.targetIri],
+        requestCompleteFn
+      });
+    }
+    return newResource;
+  }
+  getRefreshPositions(positionIri) {
+    const refreshPositions = [];
+    if (!positionIri) {
+      return refreshPositions;
+    }
+    const groupPositions = this.groupResourcePositions;
+    if (groupPositions) {
+      const currentPositions = groupPositions;
+      if (currentPositions) {
+        const index = currentPositions.indexOf(positionIri);
+        if (index !== -1) {
+          const positionsAfterInsert = groupPositions.slice(index);
+          if (positionsAfterInsert && positionsAfterInsert.length) {
+            refreshPositions.push(...positionsAfterInsert);
+          }
+        }
+      }
+    }
+    return refreshPositions;
+  }
+  get groupResource() {
+    if (!this._addResourceEvent.value || !this._addResourceEvent.value.closest.group) {
+      return;
+    }
+    return this.resourcesStore.getResource(this._addResourceEvent.value.closest.group);
+  }
+  get groupResourcePositions() {
+    if (!this.groupResource) {
+      return;
+    }
+    return this.groupResource.data?.componentPositions;
+  }
+  get resourcesStore() {
+    return this.resourcesStoreDefinition.useStore();
+  }
+  get errorStore() {
+    return this.errorStoreDefinition.useStore();
+  }
+}

package/dist/runtime/resources/resources.d.ts

@@ -0,0 +1,53 @@
+import { type ComputedRef } from 'vue';
+import type { ResourcesStore } from '../storage/stores/resources/resources-store.js';
+import type { CwaCurrentResourceInterface } from '../storage/stores/resources/state.js';
+import type { FetcherStore } from '../storage/stores/fetcher/fetcher-store.js';
+import type { AddResourceEvent } from '#cwa/runtime/admin/resource-stack-manager';
+interface PageLoadStatus {
+    resources: (string | undefined)[];
+    total: number;
+    complete: number;
+    percent: number;
+}
+export declare class Resources {
+    private readonly resourcesStoreDefinition;
+    private readonly fetcherStoreDefinition;
+    constructor(resourcesStoreDefinition: ResourcesStore, fetcherStoreDefinition: FetcherStore);
+    get currentIds(): string[];
+    isIriPublishableEquivalent(oldIri: string, newIri: string): boolean;
+    findAllPublishableIris(iri: string): string[];
+    getResource(id: string): ComputedRef<CwaCurrentResourceInterface | undefined>;
+    getChildIris(iri: string, addResourceEvent: undefined | AddResourceEvent): string[];
+    get newResource(): ComputedRef<CwaCurrentResourceInterface | undefined>;
+    getComponentGroupByReference(reference: string): CwaCurrentResourceInterface | undefined;
+    get currentResources(): {
+        [key: string]: CwaCurrentResourceInterface;
+    };
+    private get displayFetchStatus();
+    private get pageLoadResources();
+    get pageLoadProgress(): ComputedRef<PageLoadStatus>;
+    isPageDataResource(iri: string): ComputedRef<boolean>;
+    private getFetchStatusType;
+    private getLayoutIriByFetchStatus;
+    private getPageIriByFetchStatus;
+    get pageDataIri(): ComputedRef<any>;
+    get pageData(): ComputedRef<CwaCurrentResourceInterface | undefined> | undefined;
+    get pageIri(): ComputedRef<string | undefined>;
+    get page(): ComputedRef<CwaCurrentResourceInterface | undefined> | undefined;
+    get layoutIri(): ComputedRef<string | undefined>;
+    get layout(): ComputedRef<CwaCurrentResourceInterface | undefined>;
+    findPublishedComponentIri(iri: string): ComputedRef<string | undefined>;
+    findDraftComponentIri(iri: string): ComputedRef<string | undefined>;
+    get getOrderedPositionsForGroup(): (groupIri: string, includeNewIri?: boolean) => string[] | undefined;
+    get getPositionSortDisplayNumber(): (groupIri: string, includeNewIri?: boolean) => number | undefined;
+    getRefreshEndpointsForDelete(iri: string): string[];
+    get isLoading(): ComputedRef<boolean>;
+    get resourceLoadStatus(): import("../storage/stores/resources/getters.js").ResourcesLoadStatusInterface;
+    private get fetcherStore();
+    private get resourcesStore();
+    get usesPageTemplate(): ComputedRef<boolean>;
+    get isDataPage(): ComputedRef<boolean>;
+    get isDynamicPage(): ComputedRef<boolean>;
+    get hasNewResources(): boolean;
+}
+export {};