@cwa/nuxt-edge 1.0.0-29138192.e49c1a0

package/dist/runtime/api/auth.d.ts

@@ -0,0 +1,85 @@
+import type { ComputedRef } from 'vue';
+import type { AuthStore } from '../storage/stores/auth/auth-store.js';
+import { CwaUserRoles } from '../storage/stores/auth/state.js';
+import type { ResourcesStore } from '../storage/stores/resources/resources-store.js';
+import type { FetcherStore } from '../storage/stores/fetcher/fetcher-store.js';
+import type CwaFetch from './fetcher/cwa-fetch.js';
+import type Mercure from './mercure.js';
+import type Fetcher from './fetcher/fetcher.js';
+import type { CookieRef } from '#app';
+import type Admin from '#cwa/runtime/admin/admin';
+interface Credentials {
+    username: string;
+    password: string;
+}
+export declare enum CwaAuthStatus {
+    SIGNED_OUT = 0,
+    LOADING = 1,
+    SIGNED_IN = 2
+}
+interface ResetPasswordEvent {
+    username: string;
+    token: string;
+    passwords: {
+        first: string;
+        second: string;
+    };
+}
+export default class Auth {
+    private readonly cwaFetch;
+    private readonly mercure;
+    private readonly fetcher;
+    private readonly admin;
+    private readonly authStoreDefinition;
+    private readonly resourcesStoreDefinition;
+    private readonly fetcherStoreDefinition;
+    private readonly authCookie;
+    private loading;
+    private hasCheckedMeEndpointForInit;
+    constructor(cwaFetch: CwaFetch, mercure: Mercure, fetcher: Fetcher, admin: Admin, authStoreDefinition: AuthStore, resourcesStoreDefinition: ResourcesStore, fetcherStoreDefinition: FetcherStore, authCookie: CookieRef<string | null>);
+    signIn(credentials: Credentials): Promise<any>;
+    forgotPassword(username: string): Promise<any>;
+    resetPassword(event: ResetPasswordEvent): Promise<any>;
+    signOut(): Promise<any>;
+    refreshUser(): Promise<any>;
+    init(): Promise<void>;
+    get user(): {
+        [x: string]: any;
+        emailAddress: string;
+        enabled: boolean;
+        roles: (string | CwaUserRoles)[];
+        username: string;
+        '@id': string;
+        '@type': string;
+        publishedResource?: string | undefined;
+        draftResource?: string | undefined;
+        uiComponent?: string | undefined;
+        sortValue?: number | undefined;
+        componentGroup?: string | undefined;
+        _metadata: {
+            [x: string]: any;
+            adding?: {
+                instantAdd: boolean;
+                endpoint: string;
+                isPublishable: boolean;
+            } | undefined;
+            persisted: boolean;
+            publishable?: {
+                published: boolean;
+                publishedAt: string;
+            } | undefined;
+            sortDisplayNumber?: number | undefined;
+        };
+    } | undefined;
+    get roles(): string[] | undefined;
+    get signedIn(): ComputedRef<boolean>;
+    hasRole(role: CwaUserRoles | string): boolean;
+    get isAdmin(): ComputedRef<boolean>;
+    private loginRequest;
+    get status(): ComputedRef<CwaAuthStatus>;
+    private clearSession;
+    private get authStore();
+    private get resourcesStore();
+    private get fetcherStore();
+}
+export {};

package/dist/runtime/api/auth.js

@@ -0,0 +1,183 @@
+import { FetchError } from "ofetch";
+import { computed, ref } from "vue";
+import { CwaUserRoles } from "../storage/stores/auth/state.js";
+import { useNuxtApp, useRoute, useRouter } from "#app";
+export var CwaAuthStatus = /* @__PURE__ */ ((CwaAuthStatus2) => {
+  CwaAuthStatus2[CwaAuthStatus2["SIGNED_OUT"] = 0] = "SIGNED_OUT";
+  CwaAuthStatus2[CwaAuthStatus2["LOADING"] = 1] = "LOADING";
+  CwaAuthStatus2[CwaAuthStatus2["SIGNED_IN"] = 2] = "SIGNED_IN";
+  return CwaAuthStatus2;
+})(CwaAuthStatus || {});
+export default class Auth {
+  constructor(cwaFetch, mercure, fetcher, admin, authStoreDefinition, resourcesStoreDefinition, fetcherStoreDefinition, authCookie) {
+    this.cwaFetch = cwaFetch;
+    this.mercure = mercure;
+    this.fetcher = fetcher;
+    this.admin = admin;
+    this.authStoreDefinition = authStoreDefinition;
+    this.resourcesStoreDefinition = resourcesStoreDefinition;
+    this.fetcherStoreDefinition = fetcherStoreDefinition;
+    this.authCookie = authCookie;
+    this.loading = ref(false);
+  }
+  loading;
+  hasCheckedMeEndpointForInit = false;
+  async signIn(credentials) {
+    const result = await this.loginRequest(credentials);
+    if (result instanceof FetchError) {
+      return result;
+    }
+    this.mercure.init(true);
+    return this.refreshUser();
+  }
+  async forgotPassword(username) {
+    try {
+      return await this.cwaFetch.fetch(`/password/reset/request/${encodeURIComponent(
+        username
+      )}`);
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    }
+  }
+  async resetPassword(event) {
+    try {
+      return await this.cwaFetch.fetch("/component/forms/password_reset/submit", {
+        method: "PATCH",
+        body: {
+          password_update: {
+            username: event.username,
+            plainNewPasswordConfirmationToken: event.token,
+            plainPassword: event.passwords
+          }
+        }
+      });
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    }
+  }
+  async signOut() {
+    this.loading.value = true;
+    try {
+      const result = await this.cwaFetch.fetch("/logout");
+      await this.clearSession();
+      return result;
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    } finally {
+      this.loading.value = false;
+    }
+  }
+  async refreshUser() {
+    this.loading.value = true;
+    try {
+      const user = await this.cwaFetch.fetch("/me");
+      this.authCookie.value = "1";
+      this.authStore.data.user = user;
+      return user;
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      await this.clearSession();
+      return error;
+    } finally {
+      this.loading.value = false;
+    }
+  }
+  async init() {
+    if (!this.hasCheckedMeEndpointForInit || this.signedIn.value && !this.user) {
+      this.hasCheckedMeEndpointForInit = true;
+      await this.refreshUser();
+    }
+  }
+  get user() {
+    return this.authStore.data.user;
+  }
+  get roles() {
+    if (!this.user) {
+      return;
+    }
+    return this.user.roles;
+  }
+  get signedIn() {
+    return computed(() => this.status.value === 2 /* SIGNED_IN */);
+  }
+  hasRole(role) {
+    if (!this.roles) {
+      return false;
+    }
+    return this.roles.includes(role);
+  }
+  get isAdmin() {
+    return computed(() => this.hasRole(CwaUserRoles.ADMIN));
+  }
+  async loginRequest(credentials) {
+    this.loading.value = true;
+    try {
+      return await this.cwaFetch.fetch("/login", {
+        method: "POST",
+        body: credentials
+      });
+    } catch (error) {
+      this.loading.value = false;
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    }
+  }
+  get status() {
+    return computed(() => {
+      if (this.loading.value) {
+        return 1 /* LOADING */;
+      }
+      return `${this.authCookie.value}` === "1" ? 2 /* SIGNED_IN */ : 0 /* SIGNED_OUT */;
+    });
+  }
+  async clearSession() {
+    this.authStore.data.user = void 0;
+    this.authCookie.value = "0";
+    this.admin.toggleEdit(false);
+    const isProcessingMiddleware = () => {
+      try {
+        if (useNuxtApp()._processingMiddleware) {
+          return true;
+        }
+      } catch {
+        return true;
+      }
+      return false;
+    };
+    if (isProcessingMiddleware()) {
+      return;
+    }
+    this.mercure.init(true);
+    this.resourcesStore.clearResources();
+    this.fetcherStore.clearFetches();
+    const route = useRoute();
+    if (route.meta.cwa?.admin) {
+      const router = useRouter();
+      router.replace("/");
+      return;
+    }
+    await this.fetcher.fetchRoute(route);
+  }
+  get authStore() {
+    return this.authStoreDefinition.useStore();
+  }
+  get resourcesStore() {
+    return this.resourcesStoreDefinition.useStore();
+  }
+  get fetcherStore() {
+    return this.fetcherStoreDefinition.useStore();
+  }
+}

package/dist/runtime/api/fetcher/cwa-fetch.d.ts

@@ -0,0 +1,5 @@
+import { type $Fetch } from 'ofetch';
+export default class CwaFetch {
+    readonly fetch: $Fetch;
+    constructor(baseURL: string);
+}

package/dist/runtime/api/fetcher/cwa-fetch.js

@@ -0,0 +1,20 @@
+import { $fetch } from "ofetch";
+import { useRequestHeaders } from "#imports";
+export default class CwaFetch {
+  fetch;
+  constructor(baseURL) {
+    this.fetch = $fetch.create({
+      baseURL,
+      headers: {
+        accept: "application/ld+json,application/json"
+      },
+      credentials: "include",
+      onRequest(ctx) {
+        if (import.meta.server) {
+          const { cookie } = useRequestHeaders(["cookie"]);
+          cookie && ctx.options.headers.append("cookie", cookie);
+        }
+      }
+    });
+  }
+}

package/dist/runtime/api/fetcher/fetch-status-manager.d.ts

@@ -0,0 +1,51 @@
+import type Mercure from '../mercure.js';
+import type ApiDocumentation from '../api-documentation.js';
+import type { FetcherStore } from '../../storage/stores/fetcher/fetcher-store.js';
+import type { AddFetchResourceEvent, FinishFetchEvent, ManifestErrorFetchEvent, ManifestSuccessFetchEvent, StartFetchEvent, StartFetchResponse } from '../../storage/stores/fetcher/actions.js';
+import type { ResourcesStore } from '../../storage/stores/resources/resources-store.js';
+import type { CwaResourceError } from '../../errors/cwa-resource-error.js';
+import type { CwaResource } from '../../resources/resource-utils.js';
+import type { CwaFetchRequestHeaders, CwaFetchResponse } from './fetcher.js';
+export interface FinishFetchResourceEvent {
+    resource: string;
+    success: boolean;
+    token: string;
+}
+export interface FinishFetchResourceSuccessEvent extends FinishFetchResourceEvent {
+    success: true;
+    fetchResponse: CwaFetchResponse | any;
+    headers: CwaFetchRequestHeaders;
+    noSave?: boolean;
+}
+export interface FinishFetchResourceErrorEvent extends FinishFetchResourceEvent {
+    success: false;
+    error?: CwaResourceError;
+}
+type _StartFetchEvent = Omit<StartFetchEvent, 'isCurrentSuccessResourcesResolved'>;
+/**
+ * This class manages the state across the fetcher store, resources store and additional services for API Documentation and Mercure
+ */
+export default class FetchStatusManager {
+    private fetcherStoreDefinition;
+    private readonly mercure;
+    private readonly apiDocumentation;
+    private resourcesStoreDefinition;
+    constructor(fetcherStoreDefinition: FetcherStore, mercure: Mercure, apiDocumentation: ApiDocumentation, resourcesStoreDefinition: ResourcesStore);
+    getFetchedCurrentResource(iri: string, timeout?: number): Promise<CwaResource | undefined>;
+    startFetch(event: _StartFetchEvent): StartFetchResponse;
+    startFetchResource(event: AddFetchResourceEvent): boolean;
+    finishFetchResource(event: FinishFetchResourceSuccessEvent | FinishFetchResourceErrorEvent): CwaResource | undefined;
+    finishFetch(event: FinishFetchEvent): Promise<void>;
+    private finishFetchShowError;
+    private computedFetchChainComplete;
+    private waitForFetchChainToComplete;
+    finishManifestFetch(event: ManifestSuccessFetchEvent | ManifestErrorFetchEvent): void;
+    isCurrentFetchingToken(token: string): boolean | undefined;
+    abortFetch(token: string): void;
+    clearPrimaryFetch(): void;
+    get primaryFetchPath(): string | undefined;
+    get isCurrentSuccessResourcesResolved(): boolean;
+    private get fetcherStore();
+    private get resourcesStore();
+}
+export {};

package/dist/runtime/api/fetcher/fetch-status-manager.js

@@ -0,0 +1,185 @@
+import { computed, watch, watchEffect } from "vue";
+import { consola as logger } from "consola";
+import { storeToRefs } from "pinia";
+import { createCwaResourceError } from "../../errors/cwa-resource-error.js";
+import { isCwaResource } from "../../resources/resource-utils.js";
+import { CwaResourceApiStatuses } from "../../storage/stores/resources/state.js";
+import { clearError, useError } from "#app";
+export default class FetchStatusManager {
+  fetcherStoreDefinition;
+  mercure;
+  apiDocumentation;
+  resourcesStoreDefinition;
+  constructor(fetcherStoreDefinition, mercure, apiDocumentation, resourcesStoreDefinition) {
+    this.fetcherStoreDefinition = fetcherStoreDefinition;
+    this.mercure = mercure;
+    this.apiDocumentation = apiDocumentation;
+    this.resourcesStoreDefinition = resourcesStoreDefinition;
+  }
+  async getFetchedCurrentResource(iri, timeout) {
+    const { current: { value: { byId: currentById } } } = storeToRefs(this.resourcesStore);
+    const currentResource = currentById[iri];
+    if (!currentResource) {
+      return;
+    }
+    timeout = timeout || 1e4;
+    let stopWatch;
+    const getResolvedResource = new Promise((resolve) => {
+      const tooLongTimeout = setTimeout(() => {
+        logger.warn(`Timed out ${timeout}ms waiting to fetch current resource '${iri}' in pending API state.`);
+        resolve(void 0);
+      }, timeout);
+      stopWatch = watchEffect(() => {
+        if (currentResource.apiState.status !== CwaResourceApiStatuses.IN_PROGRESS) {
+          clearTimeout(tooLongTimeout);
+          resolve(currentResource.data);
+        }
+      });
+    });
+    const resolvedResource = await getResolvedResource;
+    stopWatch();
+    return resolvedResource || currentResource.data;
+  }
+  startFetch(event) {
+    const startFetchStatus = this.fetcherStore.startFetch({ ...event, isCurrentSuccessResourcesResolved: this.isCurrentSuccessResourcesResolved });
+    if (event.isPrimary) {
+      this.resourcesStore.resetCurrentResources(startFetchStatus.resources);
+    }
+    return startFetchStatus;
+  }
+  startFetchResource(event) {
+    const addedToFetcherResources = this.fetcherStore.addFetchResource(event);
+    if (addedToFetcherResources) {
+      this.resourcesStore.setResourceFetchStatus({ iri: event.resource, isComplete: false });
+    }
+    return addedToFetcherResources;
+  }
+  finishFetchResource(event) {
+    if (this.resourcesStore.current.byId?.[event.resource]?.apiState.status === CwaResourceApiStatuses.SUCCESS) {
+      return this.resourcesStore.current.byId?.[event.resource].data;
+    }
+    const isCurrent = this.fetcherStore.isCurrentFetchingToken(event.token);
+    const fetchStatus = this.fetcherStore.fetches[event.token];
+    if (fetchStatus?.abort) {
+      this.resourcesStore.setResourceFetchError({
+        iri: event.resource,
+        error: createCwaResourceError(new Error(`Not Saved. Fetching token '${event.token}' has been aborted.`)),
+        isCurrent
+      });
+      return;
+    }
+    if (!isCurrent) {
+      this.resourcesStore.setResourceFetchError({
+        iri: event.resource,
+        error: createCwaResourceError(new Error(`Not Saved. Fetching token '${event.token}' is no longer current.`)),
+        isCurrent
+      });
+      return;
+    }
+    const showErrorPage = this.finishFetchShowError(fetchStatus, event.resource);
+    const setFinalResourceFetchError = (error) => {
+      this.resourcesStore.setResourceFetchError({
+        iri: event.resource,
+        error,
+        isCurrent,
+        showErrorPage
+      });
+    };
+    if (!event.success) {
+      setFinalResourceFetchError(event.error);
+      return;
+    }
+    const cwaResource = event.fetchResponse._data;
+    if (!isCwaResource(cwaResource)) {
+      const error = createCwaResourceError(new Error(`Not Saved. The response was not a valid CWA Resource. (${event.resource})`));
+      setFinalResourceFetchError(error);
+      logger.error("[CWA FETCH ERROR]", event.resource, cwaResource);
+      return;
+    }
+    if (this.finishFetchShowError(fetchStatus, event.resource)) {
+      const currentError = useError();
+      if (currentError.value?.error) clearError();
+    }
+    const linkHeader = event.fetchResponse.headers.get("link");
+    if (linkHeader) {
+      this.mercure.setMercureHubFromLinkHeader(linkHeader);
+      this.apiDocumentation.setDocsPathFromLinkHeader(linkHeader);
+    }
+    if (!event.noSave) {
+      this.resourcesStore.saveResource({
+        resource: cwaResource
+      });
+    }
+    this.resourcesStore.setResourceFetchStatus({ iri: event.resource, isComplete: true, headers: event.headers });
+    return cwaResource;
+  }
+  async finishFetch(event) {
+    await this.waitForFetchChainToComplete(event.token);
+    this.fetcherStore.finishFetch(event);
+  }
+  finishFetchShowError(fetchStatus, eventResource) {
+    return !!fetchStatus?.isPrimary && fetchStatus?.path === eventResource;
+  }
+  computedFetchChainComplete(token) {
+    return computed(() => {
+      const resolvingResponse = this.fetcherStore.isFetchResolving(token);
+      if (resolvingResponse.resolving) {
+        return false;
+      }
+      if (resolvingResponse.fetchStatus?.abort) {
+        return true;
+      }
+      const resources = resolvingResponse.fetchStatus?.resources;
+      if (!resources) {
+        return false;
+      }
+      return !this.resourcesStore.resourcesApiStateIsPending(resources);
+    });
+  }
+  async waitForFetchChainToComplete(token) {
+    let fetchChainCompletePromiseResolver;
+    const fetchChainCompletePromise = new Promise((resolve) => {
+      fetchChainCompletePromiseResolver = resolve;
+    });
+    const computedFetchChainComplete = this.computedFetchChainComplete(token);
+    const callback = (isFetchChainComplete) => {
+      if (isFetchChainComplete === true) {
+        fetchChainCompletePromiseResolver();
+      }
+    };
+    const stopWatch = watch(computedFetchChainComplete, callback, {
+      immediate: true
+    });
+    await fetchChainCompletePromise;
+    stopWatch();
+  }
+  finishManifestFetch(event) {
+    this.fetcherStore.finishManifestFetch(event);
+  }
+  isCurrentFetchingToken(token) {
+    return this.fetcherStore.isCurrentFetchingToken(token);
+  }
+  abortFetch(token) {
+    return this.fetcherStore.abortFetch({ token });
+  }
+  // todo: test
+  clearPrimaryFetch() {
+    this.fetcherStore.primaryFetch.successToken = void 0;
+  }
+  get primaryFetchPath() {
+    return this.fetcherStore.primaryFetchPath;
+  }
+  get isCurrentSuccessResourcesResolved() {
+    const successFetchStatus = this.fetcherStore.resolvedSuccessFetchStatus;
+    if (!successFetchStatus) {
+      return false;
+    }
+    return this.resourcesStore.isFetchStatusResourcesResolved(successFetchStatus);
+  }
+  get fetcherStore() {
+    return this.fetcherStoreDefinition.useStore();
+  }
+  get resourcesStore() {
+    return this.resourcesStoreDefinition.useStore();
+  }
+}

package/dist/runtime/api/fetcher/fetcher.d.ts

@@ -0,0 +1,57 @@
+import type { RouteLocationNormalizedLoaded } from 'vue-router';
+import type { FetchResponse } from 'ofetch';
+import type { CwaResource } from '../../resources/resource-utils.js';
+import type { ResourcesStore } from '../../storage/stores/resources/resources-store.js';
+import type CwaFetch from './cwa-fetch.js';
+import type FetchStatusManager from './fetch-status-manager.js';
+export interface FetchResourceEvent {
+    path: string;
+    token?: string;
+    manifestPath?: string;
+    preload?: string[];
+    shallowFetch?: boolean | 'noexist';
+    noSave?: boolean;
+    isPrimary?: boolean;
+    iri?: string;
+}
+export interface FetchManifestEvent {
+    manifestPath: string;
+    token: string;
+}
+export interface FetchEvent {
+    path: string;
+    noQuery?: boolean;
+    preload?: string[];
+}
+export interface CwaFetchRequestHeaders {
+    path?: string;
+    preload?: string;
+}
+export type CwaFetchResponse = FetchResponse<CwaResource | undefined>;
+export interface CwaFetchResponseRaw {
+    response: Promise<CwaFetchResponse>;
+    headers: CwaFetchRequestHeaders;
+}
+interface FetchBatchEvent {
+    paths: string[];
+    token?: string;
+    noSave?: boolean;
+    shallowFetch?: boolean | 'noexist';
+}
+export default class Fetcher {
+    private readonly cwaFetch;
+    private fetchStatusManager;
+    private currentRoute;
+    private resourcesStoreDefinition;
+    constructor(cwaFetch: CwaFetch, fetchStatusManager: FetchStatusManager, currentRoute: RouteLocationNormalizedLoaded, resourcesStoreDefinition: ResourcesStore);
+    fetchRoute(route: RouteLocationNormalizedLoaded): Promise<CwaResource | undefined>;
+    fetchResource({ path, token, manifestPath, preload, shallowFetch, noSave, isPrimary, iri: userProvidedIri }: FetchResourceEvent): Promise<CwaResource | undefined>;
+    private fetchManifest;
+    private fetchNestedResources;
+    fetchBatch({ paths, token, noSave, shallowFetch }: FetchBatchEvent): Promise<(CwaResource | undefined)[]>;
+    fetch(event: FetchEvent): CwaFetchResponseRaw;
+    private appendQueryToPath;
+    private createRequestHeaders;
+    private get resourcesStore();
+}
+export {};