Setup fsxa

.env.template

@@ -1,3 +1,4 @@
+BASE_URL=http://localhost:3000
 FSXA_API_KEY=xxxxxxxx-xxxx-xxxx-xxxxxxxx
 FSXA_CAAS=https://your-caas-api.e-spirit.cloud
 FSXA_PROJECT_ID=xxxxxxxx-xxxx-xxxx-xxxxxxxx

.eslintrc.json

@@ -7,7 +7,8 @@
   "extends": [
     "@nuxtjs/eslint-config-typescript",
     "prettier",
-    "plugin:prettier/recommended"
+    "plugin:prettier/recommended",
+    "plugin:chai-friendly/recommended"
   ],
   "parserOptions": {
     "ecmaVersion": "latest",

.github/workflows/e2eTests.yml

@@ -6,6 +6,12 @@ on:
 
 env:
   BASE_URL: ${{ secrets.BASE_URL }}
+  FSXA_MODE: ${{ secrets.FSXA_MODE }}
+  FSXA_API_KEY: ${{ secrets.FSXA_API_KEY }}
+  FSXA_NAVIGATION_SERVICE: ${{ secrets.FSXA_NAVIGATION_SERVICE }}
+  FSXA_CAAS: ${{ secrets.FSXA_CAAS }}
+  FSXA_PROJECT_ID: ${{ secrets.FSXA_PROJECT_ID }}
+  FSXA_TENANT_ID: ${{ secrets.FSXA_TENANT_ID }}
 
 jobs:
   e2etests:
@@ -36,4 +42,4 @@ jobs:
           build: npm run build
           start: npm run start
         env:
-          CYPRESS_cyBaseUrl: ${{ secrets.CY_BASE_URL }}
+          CYPRESS_cyBaseURL: ${{ secrets.CY_BASE_URL }}

.github/workflows/validation.yml

@@ -30,6 +30,9 @@ jobs:
       - name: Install packages
         run: npm ci
 
+      - name: Build nuxt app
+        run: npm run build
+
       - name: Run tests
         run: npm run test
         env:

.gitignore

@@ -1,3 +1,6 @@
+# unplugin-auto-import
+auto-imports.d.ts
+
 # Mac 
 .DS_Store
 

app.config.ts

@@ -0,0 +1,11 @@
+import { LogLevel } from "fsxa-api";
+import { FSXAFileConfig } from "./types";
+
+const fsxaConfig: FSXAFileConfig = {
+  logLevel: LogLevel.NONE,
+  devMode: false,
+  defaultLocale: "de_DE",
+  enableEventStream: false,
+};
+
+export default defineAppConfig(fsxaConfig);

cypress.env.json

@@ -1,3 +1,3 @@
 {
-  "cyBaseUrl": "http://localhost:3000"
+  "cyBaseURL": "http://localhost:3000"
 }

cypress/e2e/server/api/[endpoint].post.cy.ts

@@ -0,0 +1,239 @@
+import { ComparisonQueryOperatorEnum } from "fsxa-api";
+import { ServerErrors, FSXAProxyRoutes, FSXAApiErrors } from "~/types";
+
+const baseURL = Cypress.env("cyBaseURL");
+
+describe(`post to /api${FSXAProxyRoutes.FETCH_ELEMENT_ROUTE}`, () => {
+  beforeEach(() => {
+    cy.visit(baseURL);
+  });
+  it(`body contains existing id => return 200 and queried element`, () => {
+    const id = "ec121aab-e29a-4e35-b97a-3dc33bb50d25";
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_ELEMENT_ROUTE}`,
+      body: {
+        locale: "de_DE",
+        id,
+      },
+    }).should((response) => {
+      expect(response.body.id).to.eq(id);
+      expect(response.status).to.eq(200);
+    });
+  });
+
+  it(`body contains unknown id => return 404`, () => {
+    const id = "unknownId";
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_ELEMENT_ROUTE}`,
+      body: {
+        locale: "de_DE",
+        id,
+      },
+      failOnStatusCode: false,
+    }).should((response) => {
+      expect(response.status).to.eq(404);
+      expect(response.body.message).to.eq(FSXAApiErrors.NOT_FOUND);
+    });
+  });
+
+  // TODO
+  it.skip(`missing permissions => return 401`, () => {});
+
+  it(`body is invalid => return 500`, () => {
+    cy.eventNames();
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_ELEMENT_ROUTE}`,
+      body: {
+        locale: "de_DE",
+      },
+      failOnStatusCode: false,
+    }).should((response) => {
+      expect(response.status).to.eq(500);
+      expect(response.body.message).to.exist;
+    });
+  });
+});
+
+describe(`post to /api${FSXAProxyRoutes.FETCH_BY_FILTER_ROUTE}`, () => {
+  beforeEach(() => {
+    cy.visit(baseURL);
+  });
+  it(`query existing elements => return 200 and filtered elements`, () => {
+    const id = "ec121aab-e29a-4e35-b97a-3dc33bb50d25";
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_BY_FILTER_ROUTE}`,
+      body: {
+        locale: "de_DE",
+        filters: [
+          {
+            value: id,
+            field: "identifier",
+            operator: ComparisonQueryOperatorEnum.EQUALS,
+          },
+        ],
+      },
+    }).should((response) => {
+      expect(response.body.items[0].id).to.eq(id);
+      expect(response.status).to.eq(200);
+    });
+  });
+
+  it(`query unknown elements => return 200 and empty items array`, () => {
+    const id = "unknownId";
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_BY_FILTER_ROUTE}`,
+      body: {
+        locale: "de_DE",
+        filters: [
+          {
+            value: id,
+            field: "identifier",
+            operator: ComparisonQueryOperatorEnum.EQUALS,
+          },
+        ],
+      },
+    }).should((response) => {
+      expect(response.body.items).to.be.empty;
+      expect(response.status).to.eq(200);
+    });
+  });
+
+  // TODO
+  it.skip(`missing permissions => return 401`, () => {});
+
+  it(`body is invalid => return 500`, () => {
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_BY_FILTER_ROUTE}`,
+      body: {
+        locale: "de_DE",
+        filters: [
+          {
+            field: "identifier",
+            operator: ComparisonQueryOperatorEnum.EQUALS,
+          },
+        ],
+      },
+      failOnStatusCode: false,
+    }).should((response) => {
+      expect(response.body.message).to.exist;
+      expect(response.status).to.eq(500);
+    });
+  });
+});
+
+describe(`post to /api${FSXAProxyRoutes.FETCH_NAVIGATION_ROUTE}`, () => {
+  beforeEach(() => {
+    cy.visit(baseURL);
+  });
+  it(`body contains valid locale => return navigation data`, () => {
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_NAVIGATION_ROUTE}`,
+      body: {
+        locale: "de_DE",
+      },
+    }).should((response) => {
+      expect(response.body).to.have.all.keys([
+        "idMap",
+        "pages",
+        "seoRouteMap",
+        "structure",
+        "meta",
+      ]);
+      expect(response.status).to.eq(200);
+    });
+  });
+
+  it(`body contains invalid locale => return 404`, () => {
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_NAVIGATION_ROUTE}`,
+      body: {
+        locale: "invalid_locale",
+      },
+      failOnStatusCode: false,
+    }).should((response) => {
+      expect(response.status).to.eq(404);
+      expect(response.body.message).to.eq(FSXAApiErrors.NOT_FOUND);
+    });
+  });
+
+  // TODO
+  it.skip(`missing permissions => return 401`, () => {});
+
+  it(`body is invalid => return 500`, () => {
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_NAVIGATION_ROUTE}`,
+      body: { locale: "invalidLocaleFormat" },
+      failOnStatusCode: false,
+    }).should((response) => {
+      expect(response.status).to.eq(500);
+      expect(response.body.message).to.exist;
+    });
+  });
+});
+
+describe(`post to /api${FSXAProxyRoutes.FETCH_PROPERTIES_ROUTE}`, () => {
+  beforeEach(() => {
+    cy.visit(baseURL);
+  });
+  it(`body contains valid locale => return project properties`, () => {
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_PROPERTIES_ROUTE}`,
+      body: { locale: "de_DE" },
+    }).should((response) => {
+      expect(response.body.type).to.eq("ProjectProperties");
+      expect(response.status).to.eq(200);
+    });
+  });
+
+  // TODO
+  it.skip(`body contains ? => return 404`, () => {});
+
+  // Tmissing permissions => return 401`, () => {});
+
+  it(`body is invalid => return 500`, () => {
+    cy.request({
+      method: "POST",
+      url: `${baseURL}/api${FSXAProxyRoutes.FETCH_PROPERTIES_ROUTE}`,
+      body: { locale: "invalidLocaleFormat" },
+      failOnStatusCode: false,
+    }).should((response) => {
+      expect(response.body.message).to.exist;
+      expect(response.status).to.eq(500);
+    });
+  });
+});
+
+it("Unknown route", () => {
+  cy.visit(baseURL);
+  cy.request({
+    method: "POST",
+    url: `${baseURL}/api/unknown`,
+    body: {},
+    failOnStatusCode: false,
+  }).should((response) => {
+    expect(response.status).to.eq(500);
+    expect(response.body.message).to.eq(ServerErrors.UNKNOWN_ROUTE);
+  });
+});
+
+it(`get /api${FSXAProxyRoutes.STREAM_CHANGE_EVENTS_ROUTE} => return 200`, () => {
+  cy.visit(baseURL);
+  cy.request({
+    method: "GET",
+    url: `${baseURL}/api${FSXAProxyRoutes.STREAM_CHANGE_EVENTS_ROUTE}`,
+    body: {},
+    failOnStatusCode: false,
+  }).should((response) => {
+    expect(response.status).to.eq(200);
+  });
+});

nuxt.config.ts

@@ -16,16 +16,38 @@ export default defineNuxtConfig({
   },
   vite: {
     plugins: [eslintPlugin()],
+    resolve: {
+      alias: {
+        util: "rollup-plugin-node-polyfills/polyfills/util",
+      },
+    },
+    optimizeDeps: {
+      esbuildOptions: {
+        define: {
+          global: "globalThis",
+        },
+      },
+    },
   },
   typescript: {
     typeCheck: true,
   },
   runtimeConfig: {
     public: {
-      baseUrl: process.env["BASE_URL"],
+      baseURL: process.env["BASE_URL"] || "http://localhost:3000",
+      logLevel: process.env["FSXA_LOG_LEVEL"],
     },
     private: {
-      fsxaApiKey: process.env["FSXA_API_KEY"],
+      apiKey: process.env["FSXA_API_KEY"],
+      navigationService: process.env["FSXA_NAVIGATION_SERVICE"],
+      caas: process.env["FSXA_CAAS"],
+      projectId: process.env["FSXA_PROJECT_ID"],
+      tenantId: process.env["FSXA_TENANT_ID"],
+      remotes: process.env["FSXA_REMOTES"],
+      maxReferenceDepth: process.env["MAX_REFERENCE_DEPTH"],
+      mode: process.env["FSXA_MODE"],
+      devMode: process.env["FSXA_DEV_MODE"],
+      snapUrl: process.env["FSXA_SNAP_URL"],
     },
   },
 });