@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/api/api-documentation.js

@@ -0,0 +1,131 @@
+import { ref, watch } from "vue";
+import { consola as logger } from "consola";
+import { CwaResourceTypes, getResourceTypeFromIri } from "#cwa/resources/resource-utils";
+export default class ApiDocumentation {
+  cwaFetch;
+  _store;
+  apiDocsSet = ref(false);
+  apiDocPromise;
+  constructor(cwaFetch, store) {
+    this.cwaFetch = cwaFetch;
+    this._store = store.useStore();
+  }
+  setDocsPathFromLinkHeader(linkHeader) {
+    this.apiDocsSet.value = this.apiDocsSet.value || !!this.docsPath;
+    if (this.apiDocsSet.value) {
+      return;
+    }
+    const matches = /<(.+)>; rel="http:\/\/www.w3.org\/ns\/hydra\/core#apiDocumentation"/.exec(
+      linkHeader
+    );
+    if (!matches || !matches[1]) {
+      logger.error(
+        'The "Link" HTTP header is not of the type "http://www.w3.org/ns/hydra/core#apiDocumentation".'
+      );
+      return;
+    }
+    this.store.$patch({
+      docsPath: matches[1]
+    });
+    this.apiDocsSet.value = true;
+    logger.debug("ApiDocumentation docsPath", this.docsPath);
+  }
+  async getApiDocumentation(refresh = false) {
+    if (!this.docsPath) {
+      logger.debug("Waiting for docsPath to bet set to fetch API Documentation");
+      return this.reRunGetApiDocumentationWhenReady(refresh);
+    }
+    const currentDocs = this.getCurrentApiDocs(refresh);
+    if (currentDocs) {
+      return currentDocs;
+    }
+    logger.debug("Fetching API Documentation");
+    return await this.fetchAllApiDocumentation(this.docsPath);
+  }
+  async getComponentMetadata(refresh = false, includePosition = false) {
+    const apiDocumentation = await this.getApiDocumentation(refresh);
+    const docs = apiDocumentation?.docs;
+    const entrypoint = apiDocumentation?.entrypoint;
+    if (!docs || !entrypoint) {
+      return;
+    }
+    const properties = docs["supportedClass"].reduce(
+      (obj, supportedClass) => {
+        obj[supportedClass["title"]] = supportedClass["supportedProperty"].map((supportedProperty) => supportedProperty["title"]);
+        return obj;
+      },
+      {}
+    );
+    const metadata = {};
+    const typeCheckArray = [CwaResourceTypes.COMPONENT];
+    if (includePosition) {
+      typeCheckArray.push(CwaResourceTypes.COMPONENT_POSITION);
+    }
+    for (const [key, endpoint] of Object.entries(entrypoint)) {
+      const rType = getResourceTypeFromIri(endpoint);
+      if (rType && typeCheckArray.includes(rType)) {
+        const resourceName = key.charAt(0).toUpperCase() + key.slice(1);
+        const isPublishable = properties?.[resourceName]?.includes("publishedAt") || false;
+        metadata[resourceName] = {
+          resourceName,
+          endpoint,
+          isPublishable
+        };
+      }
+    }
+    return metadata;
+  }
+  reRunGetApiDocumentationWhenReady(refresh = false) {
+    return new Promise((resolve) => {
+      watch(this.apiDocsSet, async (isSet) => {
+        if (isSet) {
+          const docs = await this.getApiDocumentation(refresh);
+          resolve(docs);
+        }
+      });
+    });
+  }
+  getCurrentApiDocs(refresh) {
+    if (!this.apiDocPromise && !refresh && this.store.$state.apiDocumentation) {
+      logger.debug("Not refreshing API Documentation. Returning cached data.");
+      return this.store.$state.apiDocumentation;
+    }
+    return null;
+  }
+  async awaitApiDocPromise() {
+    logger.debug("Waiting for previous request to complete for API Documentation");
+    await this.apiDocPromise;
+    return this.store.$state.apiDocumentation;
+  }
+  async fetchAllApiDocumentation(docsPath) {
+    if (this.apiDocPromise) {
+      return await this.awaitApiDocPromise();
+    }
+    this.apiDocPromise = Promise.all([
+      this.doRequest("/"),
+      this.doRequest(docsPath),
+      this.doRequest("/_/page_data_metadatas")
+    ]).then((responses) => {
+      this.store.$patch({
+        apiDocumentation: {
+          entrypoint: responses[0],
+          docs: responses[1],
+          pageDataMetadata: responses[2]
+        }
+      });
+      logger.debug("New API Documentation Saved");
+      this.apiDocPromise = void 0;
+    });
+    await this.apiDocPromise;
+    return this.store.$state.apiDocumentation;
+  }
+  async doRequest(path) {
+    return await this.cwaFetch.fetch(path);
+  }
+  get store() {
+    return this._store;
+  }
+  get docsPath() {
+    return this.store.$state.docsPath;
+  }
+}

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

@@ -0,0 +1,100 @@
+import type { CookieRef } from 'nuxt/app';
+import { FetchError } from 'ofetch';
+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 { CwaUser } 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 Admin from '#cwa/admin/admin';
+import type ApiDocumentation from '#cwa/api/api-documentation';
+interface Credentials {
+    username: string;
+    password: string;
+}
+export declare enum CwaAuthStatus {
+    SIGNED_OUT = 0,
+    LOADING = 1,
+    SIGNED_IN = 2
+}
+interface BaseTokenUserEvent {
+    username: string;
+    token: string;
+}
+interface ConfirmNewEmailEvent extends BaseTokenUserEvent {
+    newEmail: string;
+}
+interface ResetPasswordEvent extends BaseTokenUserEvent {
+    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 apiDocumentation;
+    private readonly authCookie;
+    private loading;
+    private hasCheckedMeEndpointForInit;
+    private readonly _authStore;
+    private readonly _resourcesStore;
+    private readonly _fetcherStore;
+    constructor(cwaFetch: CwaFetch, mercure: Mercure, fetcher: Fetcher, admin: Admin, apiDocumentation: ApiDocumentation, authStoreDefinition: AuthStore, resourcesStoreDefinition: ResourcesStore, fetcherStoreDefinition: FetcherStore, authCookie: CookieRef<string | null>);
+    signIn(credentials: Credentials): Promise<CwaUser | FetchError<any> | undefined>;
+    forgotPassword(username: string): Promise<any>;
+    resendVerifyEmail(username: string): Promise<any>;
+    resendVerifyNewEmail(username: string): Promise<any>;
+    confirmEmail(event: ConfirmNewEmailEvent): Promise<any>;
+    verifyEmail(event: BaseTokenUserEvent): Promise<any>;
+    resetPassword(event: ResetPasswordEvent): Promise<any>;
+    signOut(): Promise<any>;
+    refreshUser(): Promise<CwaUser | FetchError<any> | undefined>;
+    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,264 @@
+import { FetchError } from "ofetch";
+import { computed, ref } from "vue";
+import { CwaUserRoles } from "../storage/stores/auth/state.js";
+import { useNuxtApp, useRoute, useRouter } from "#imports";
+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, apiDocumentation, authStoreDefinition, resourcesStoreDefinition, fetcherStoreDefinition, authCookie) {
+    this.cwaFetch = cwaFetch;
+    this.mercure = mercure;
+    this.fetcher = fetcher;
+    this.admin = admin;
+    this.apiDocumentation = apiDocumentation;
+    this.authCookie = authCookie;
+    this.loading = ref(false);
+    this._authStore = authStoreDefinition.useStore();
+    this._resourcesStore = resourcesStoreDefinition.useStore();
+    this._fetcherStore = fetcherStoreDefinition.useStore();
+  }
+  cwaFetch;
+  mercure;
+  fetcher;
+  admin;
+  apiDocumentation;
+  authCookie;
+  loading;
+  hasCheckedMeEndpointForInit = false;
+  _authStore;
+  _resourcesStore;
+  _fetcherStore;
+  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
+      )}`, {
+        retry: 0
+      });
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    }
+  }
+  async resendVerifyEmail(username) {
+    try {
+      return await this.cwaFetch.fetch(`/resend-verify-email/${encodeURIComponent(
+        username
+      )}`, {
+        retry: 0
+      });
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    }
+  }
+  async resendVerifyNewEmail(username) {
+    try {
+      return await this.cwaFetch.fetch(`/resend-verify-new-email/${encodeURIComponent(
+        username
+      )}`, {
+        retry: 0
+      });
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    }
+  }
+  async confirmEmail(event) {
+    try {
+      return await this.cwaFetch.fetch(`/confirm-email/${encodeURIComponent(
+        event.username
+      )}/${encodeURIComponent(
+        event.newEmail
+      )}/${encodeURIComponent(
+        event.token
+      )}`, {
+        retry: 0
+      });
+    } catch (error) {
+      if (!(error instanceof FetchError)) {
+        throw error;
+      }
+      return error;
+    }
+  }
+  async verifyEmail(event) {
+    try {
+      return await this.cwaFetch.fetch(`/verify-email/${encodeURIComponent(
+        event.username
+      )}/${encodeURIComponent(
+        event.token
+      )}`, {
+        retry: 0
+      });
+    } 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: "POST",
+        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", {
+        method: "POST"
+      });
+      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 { headers, _data: user } = await this.cwaFetch.fetch.raw("/me");
+      const linkHeader = headers.get("link");
+      if (linkHeader) {
+        this.mercure.setMercureHubFromLinkHeader(linkHeader);
+        this.apiDocumentation.setDocsPathFromLinkHeader(linkHeader);
+      }
+      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._authStore;
+  }
+  get resourcesStore() {
+    return this._resourcesStore;
+  }
+  get fetcherStore() {
+    return this._fetcherStore;
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { $Fetch } from 'ofetch';
+import type { RequestHeaders } from 'h3';
+interface RequestOptions {
+    headers: Partial<RequestHeaders>;
+    method: 'POST' | 'PATCH' | 'DELETE';
+}
+export default class CwaFetch {
+    readonly fetch: $Fetch;
+    constructor(baseURL: string);
+    getRequestOptions(method: 'POST' | 'PATCH' | 'DELETE'): RequestOptions;
+}
+export {};

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

@@ -0,0 +1,43 @@
+import { $fetch } from "ofetch";
+import { useRequestHeaders } from "#imports";
+export default class CwaFetch {
+  fetch;
+  constructor(baseURL) {
+    this.fetch = $fetch.create({
+      baseURL,
+      retryDelay: 200,
+      headers: {
+        accept: "application/ld+json,application/json"
+      },
+      credentials: "include",
+      onRequest(ctx) {
+        const baseUrlObj = new URL(baseURL);
+        const prefix = baseUrlObj.pathname;
+        const checkRequestForPrefix = (reqPath) => {
+          if (reqPath.startsWith(prefix)) {
+            ctx.options.baseURL = baseUrlObj.origin;
+          }
+        };
+        if (typeof ctx.request === "string") {
+          checkRequestForPrefix(ctx.request);
+        } else {
+          checkRequestForPrefix(ctx.request.url);
+        }
+        if (import.meta.server) {
+          const { cookie } = useRequestHeaders(["cookie"]);
+          cookie && ctx.options.headers.append("cookie", cookie);
+        }
+      }
+    });
+  }
+  getRequestOptions(method) {
+    const headers = {
+      accept: "application/ld+json,application/json"
+    };
+    headers["content-type"] = method === "PATCH" ? "application/merge-patch+json" : "application/ld+json";
+    return {
+      method,
+      headers
+    };
+  }
+}

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

@@ -0,0 +1,59 @@
+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, SetManifestIrisByDepthEvent, 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;
+    userProvidedIri?: string;
+    success: boolean;
+    token: string;
+    path: 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 readonly mercure;
+    private readonly apiDocumentation;
+    private readonly _fetcherStore;
+    private readonly _resourcesStore;
+    private _iriToDepth;
+    private _depthPaths;
+    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;
+    setManifestIrisByDepth(event: SetManifestIrisByDepthEvent): void;
+    getDepthForIri(iri: string): number | undefined;
+    getPathForDepth(depth: number): string | undefined;
+    registerIriDepth(iri: string, depth: number): void;
+    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 {};