@raketa-cloud/next 1.0.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@raketa-cloud/next",
+  "version": "1.0.0",
+  "main": "src/index.js",
+  "scripts": {
+    "check-types": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*",
+    "@turbo/gen": "^1.12.4",
+    "@types/node": "^20.11.24",
+    "@types/react": "18.3.0",
+    "@types/react-dom": "18.3.1",
+    "typescript": "5.5.4"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "graphql-request": "7.1.2",
+    "lru-cache": "11.0.2"
+  }
+}

package/src/Cache.js

@@ -0,0 +1,95 @@
+import { LRUCache } from "lru-cache";
+
+const UNDEFINED_VALUE = Symbol("udef");
+
+export default class Cache {
+  constructor(opts = {}) {
+    const cacheOptions = {
+      max: opts.max || 5000,
+      ttl: opts.ttl || 1000 * 60 * 2,
+      allowStale: true,
+      noDeleteOnStaleGet: true,
+    };
+
+    this.debugMode = opts.debugMode || false;
+    this.cacheInstance = new LRUCache({
+      ...cacheOptions,
+    });
+  }
+
+  _debug(msg) {
+    if (this.debugMode) {
+      console.log(msg);
+    }
+  }
+
+  _fetchFromCache(key) {
+    const status = {};
+
+    const cachedValue = this.cacheInstance.get(key, { status });
+
+    return {
+      cachedValue: cachedValue === UNDEFINED_VALUE ? null : cachedValue,
+      status,
+    };
+  }
+
+  _cloneObject(obj) {
+    // Ah the JS world! See the official docs https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy.
+    // Important note - this works only for objects with primitive types to copy. If an object property is
+    // a function - well it will not work correctly...
+    return JSON.parse(JSON.stringify(obj));
+  }
+
+  _setInCache(key, value) {
+    this.cacheInstance.set(
+      key,
+      value ? this._cloneObject(value) : UNDEFINED_VALUE
+    );
+  }
+
+  async fetch(cacheKey, fetcher) {
+    const { cachedValue, status } = this._fetchFromCache(cacheKey);
+
+    if (status.get === "hit") {
+      this._debug(`Cache HIT: ${cacheKey}`);
+      return this._cloneObject(cachedValue);
+    }
+
+    if (status.get === "stale") {
+      this._debug(`Cache STALE: ${cacheKey}`);
+
+      try {
+        const freshEntity = await fetcher();
+
+        this._setInCache(cacheKey, freshEntity);
+
+        return this._cloneObject(freshEntity);
+      } catch (e) {
+        console.error(e);
+
+        // Reset TTL
+        this._setInCache(cacheKey, cachedValue);
+
+        return this._cloneObject(cachedValue);
+      }
+    }
+
+    try {
+      this._debug(`Cache MISS: ${cacheKey}`);
+
+      const freshEntity = await fetcher();
+
+      this._setInCache(cacheKey, freshEntity);
+
+      return this._cloneObject(freshEntity);
+    } catch (e) {
+      console.error(e);
+
+      // Reset TTL
+      this._setInCache(cacheKey, cachedValue);
+
+      return this._cloneObject(cachedValue);
+    }
+  }
+}

package/src/cloud/public.js

@@ -0,0 +1,7 @@
+export default function generateCloudPublicHelpers(dxpPublic) {
+  return {
+    findRedirect: async function (path) {
+      return await dxpPublic.redirects.find(path, { withCache: true });
+    },
+  };
+}

package/src/dxp/graphql.js

@@ -0,0 +1,11 @@
+import { request, gql } from "graphql-request";
+
+const gqlRequest = (url, query, variables = {}, headers = {}) =>
+  request({
+    url,
+    document: query,
+    variables: variables,
+    requestHeaders: headers,
+  });
+
+export { gqlRequest, gql };

package/src/dxp/private/Articles.js

@@ -0,0 +1,30 @@
+import DxpModel from "./DxpModel";
+import {
+  ArticleChangePreviewDocument,
+  MiniArticlesDocument,
+} from "./documents/articlesDocuments";
+
+export default class Pages extends DxpModel {
+  async articleChangePreview(locale, id, version) {
+    const response = await this.client.query(ArticleChangePreviewDocument, {
+      input: {
+        locale,
+        articleId: id,
+        version,
+      },
+    });
+
+    return response?.articleChangePreview;
+  }
+
+  async miniArticles(locale, input = {}) {
+    const response = await this.client.query(MiniArticlesDocument, {
+      input: {
+        locale,
+        ...input,
+      },
+    });
+
+    return response?.miniArticles;
+  }
+}

package/src/dxp/private/Dxp.js

@@ -0,0 +1,17 @@
+import DxpClient from "./DxpClient";
+import Pages from "./Pages";
+import Articles from "./Articles";
+import Events from "./Events";
+import Settings from "./Settings";
+import Tags from "./Tags";
+
+export default class Dxp {
+  constructor(getConfig, getToken) {
+    this.client = new DxpClient(getConfig, getToken);
+    this.pages = new Pages(this.client);
+    this.articles = new Articles(this.client);
+    this.events = new Events(this.client);
+    this.settings = new Settings(this.client);
+    this.tags = new Tags(this.client);
+  }
+}

package/src/dxp/private/DxpClient.js

@@ -0,0 +1,32 @@
+import { gql, request } from "graphql-request";
+
+export default class DxpClient {
+  constructor(getConfig, getToken) {
+    this.getConfig = getConfig;
+    this.getToken = getToken;
+    this.gql = gql;
+  }
+
+  _gqlRequest(url, query, variables = {}, headers = {}) {
+    return request({
+      url,
+      document: query,
+      variables: variables,
+      requestHeaders: headers,
+    });
+  }
+
+  async query(query, variables = {}) {
+    const token = await this.getToken();
+    return this._gqlRequest(
+      `${this.getConfig().cloud.gateway_url}/dispatch`,
+      query,
+      variables,
+      {
+        "x-raketa-project": this.getConfig().cloud.gateway_project,
+        "x-raketa-service": this.getConfig().cloud.dxp_service_private,
+        "x-raketa-identity": token,
+      }
+    );
+  }
+}

package/src/dxp/private/DxpModel.js

@@ -0,0 +1,5 @@
+export default class DxpModel {
+  constructor(client) {
+    this.client = client;
+  }
+}

package/src/dxp/private/Events.js

@@ -0,0 +1,30 @@
+import DxpModel from "./DxpModel";
+import {
+  EventChangePreviewDocument,
+  MiniEventsDocument,
+} from "./documents/eventsDocuments";
+
+export default class Pages extends DxpModel {
+  async eventChangePreview(locale, id, version) {
+    const response = await this.client.query(EventChangePreviewDocument, {
+      input: {
+        locale,
+        eventId: id,
+        version,
+      },
+    });
+
+    return response?.eventChangePreview;
+  }
+
+  async miniEvents(locale, input = {}) {
+    const response = await this.client.query(MiniEventsDocument, {
+      input: {
+        locale,
+        ...input,
+      },
+    });
+
+    return response?.miniEvents;
+  }
+}

package/src/dxp/private/Pages.js

@@ -0,0 +1,30 @@
+import DxpModel from "./DxpModel";
+import {
+  PageChangePreviewDocument,
+  MiniPagesDocument,
+} from "./documents/pagesDocuments";
+
+export default class Pages extends DxpModel {
+  async pageChangePreview(locale, id, version) {
+    const response = await this.client.query(PageChangePreviewDocument, {
+      input: {
+        locale,
+        pageId: id,
+        version,
+      },
+    });
+
+    return response?.pageChangePreview;
+  }
+
+  async miniPages(locale, input = {}) {
+    const response = await this.client.query(MiniPagesDocument, {
+      input: {
+        locale,
+        ...input,
+      },
+    });
+
+    return response?.miniPages;
+  }
+}

package/src/dxp/private/Settings.js

@@ -0,0 +1,12 @@
+import DxpModel from "./DxpModel";
+import { SettingDocument } from "./documents/settingsDocuments";
+
+export default class Settings extends DxpModel {
+  async find(locale) {
+    const response = await this.client.query(SettingDocument, {
+      locale,
+    });
+
+    return response?.setting;
+  }
+}

package/src/dxp/private/Tags.js

@@ -0,0 +1,26 @@
+import DxpModel from "./DxpModel";
+import { TagsDocument } from "./documents/tagDocuments";
+
+export default class Tags extends DxpModel {
+  async list(locale, input = {}) {
+    let inp = {};
+
+    if (input?.pagination?.page) {
+      inp = Object.assign({}, input, {
+        pagination: {
+          page: this.coercePageNumber(input.pagination?.page || 1),
+          pageSize: input.pagination?.pageSize || 12,
+        },
+        locale,
+      });
+    } else {
+      inp = { ...input, locale };
+    }
+
+    const response = await this.client.query(TagsDocument, {
+      input: inp,
+    });
+
+    return response?.tags;
+  }
+}

package/src/dxp/private/documents/articlesDocuments.js

@@ -0,0 +1,69 @@
+import { gql } from "../../graphql";
+import { tagFragment, categoryFragment, resourceTypeFragment } from "./common";
+
+const ArticleByIdDocument = gql`
+  query ArticleByID($input: IdInput!) {
+    article(input: $input) {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      translations
+      tags ${tagFragment()}
+      categories ${categoryFragment()}
+      articleType ${resourceTypeFragment()}
+    }
+  }
+`;
+
+const ArticleChangePreviewDocument = gql`
+  query ($input: ArticleChangePreviewInput!) {
+    articleChangePreview(input: $input) {
+      article {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        publishAt
+        translations
+        websiteSettings
+        tags ${tagFragment()}
+        categories ${categoryFragment()}
+        articleType ${resourceTypeFragment()}
+      }
+      articleChange {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
+const MiniArticlesDocument = gql`
+  query ($input: ArticlesInput!) {
+    miniArticles(input: $input) {
+      list {
+        id
+        slug
+        title
+        visibility
+      }
+    }
+  }
+`;
+
+export {
+  ArticleByIdDocument,
+  ArticleChangePreviewDocument,
+  MiniArticlesDocument,
+};

package/src/dxp/private/documents/common.js

@@ -0,0 +1,44 @@
+import { gql } from "../../graphql";
+
+export function tagFragment() {
+  return gql`
+    {
+      id
+      name
+      slug
+    }
+  `;
+}
+
+export function categoryFragment() {
+  return gql`
+    {
+      id
+      type
+      slug
+      name
+      settings
+    }
+  `;
+}
+
+export function resourceTypeFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+    }
+  `;
+}
+
+export function paginationFragment() {
+  return gql`
+    {
+      currentPage
+      pagesCount
+      entriesCount
+      pageSize
+    }
+  `;
+}

package/src/dxp/private/documents/eventsDocuments.js

@@ -0,0 +1,69 @@
+import { gql } from "../../graphql";
+import { tagFragment, categoryFragment, resourceTypeFragment } from "./common";
+
+const EventByIdDocument = gql`
+  query EventByID($input: IdInput!) {
+    event(input: $input) {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      startsAt
+      endsAt
+      translations
+      tags ${tagFragment()}
+      categories ${categoryFragment()}
+      eventType ${resourceTypeFragment()}
+    }
+  }
+`;
+
+const EventChangePreviewDocument = gql`
+  query ($input: EventChangePreviewInput!) {
+    eventChangePreview(input: $input) {
+      event {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        publishAt
+        startsAt
+        endsAt
+        translations
+        websiteSettings
+        tags ${tagFragment()}
+        categories ${categoryFragment()}
+        eventType ${resourceTypeFragment()}
+      }
+      eventChange {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
+const MiniEventsDocument = gql`
+  query ($input: EventsInput!) {
+    miniEvents(input: $input) {
+      list {
+        id
+        slug
+        title
+        visibility
+      }
+    }
+  }
+`;
+
+export { EventByIdDocument, EventChangePreviewDocument, MiniEventsDocument };

package/src/dxp/private/documents/pagesDocuments.js

@@ -0,0 +1,64 @@
+import { gql } from "../../graphql";
+import { tagFragment, categoryFragment, resourceTypeFragment } from "./common";
+
+const PageByIdDocument = gql`
+  query PageByID($input: IdInput!) {
+    page(input: $input) {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      translations
+      revisionsCount
+      tags ${tagFragment()}
+      categories ${categoryFragment()}
+      pageType ${resourceTypeFragment()}
+    }
+  }
+`;
+
+const PageChangePreviewDocument = gql`
+  query ($input: PageChangePreviewInput!) {
+    pageChangePreview(input: $input) {
+      page {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        translations
+        websiteSettings
+        tags ${tagFragment()}
+        categories ${categoryFragment()}
+        pageType ${resourceTypeFragment()}
+      }
+      pageChange {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
+const MiniPagesDocument = gql`
+  query ($input: PagesInput!) {
+    miniPages(input: $input) {
+      list {
+        id
+        slug
+        title
+        visibility
+      }
+    }
+  }
+`;
+
+export { PageByIdDocument, PageChangePreviewDocument, MiniPagesDocument };

package/src/dxp/private/documents/settingsDocuments.js

@@ -0,0 +1,11 @@
+import { gql } from "../../graphql";
+
+const SettingDocument = gql`
+  query Setting($locale: String!) {
+    setting(locale: $locale) {
+      value
+    }
+  }
+`;
+
+export { SettingDocument };

package/src/dxp/private/documents/tagDocuments.js

@@ -0,0 +1,13 @@
+import { gql } from "../../graphql";
+import { tagFragment, paginationFragment } from "./common";
+
+const TagsDocument = gql`
+  query Tags($input: TagsInput!) {
+    tags(input: $input) {
+      list ${tagFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+export { TagsDocument };

package/src/dxp/private/index.js

@@ -0,0 +1,3 @@
+import Dxp from "./Dxp";
+
+export default Dxp;

package/src/dxp/public/Articles.js

@@ -0,0 +1,38 @@
+import DxpModel from "./DxpModel";
+import { ArticleBySlugDocument, ArticlesDocument } from "./documents";
+
+export default class Articles extends DxpModel {
+  async find(locale, slug, opts = {}) {
+    const response = await this.fetch(
+      `article-${locale}-${slug}`,
+      async () =>
+        await this.client.query(
+          ArticleBySlugDocument,
+          {
+            input: {
+              locale,
+              slug,
+            },
+          },
+          opts
+        ),
+      opts
+    );
+
+    return response?.article;
+  }
+
+  async list(locale, input = {}, opts = {}) {
+    const response = await this.fetch(
+      `articles-${locale}-${JSON.stringify(input)}`,
+      async () =>
+        await this.client.query(
+          ArticlesDocument,
+          this.formatPaginationInInput(locale, input),
+          opts
+        )
+    );
+
+    return response?.articles;
+  }
+}

package/src/dxp/public/Dxp.js

@@ -0,0 +1,19 @@
+import DxpClient from "./DxpClient";
+import Pages from "./Pages";
+import Articles from "./Articles";
+import Events from "./Events";
+import Settings from "./Settings";
+import Tags from "./Tags";
+import Redirects from "./Redirects";
+
+export default class Dxp {
+  constructor(getConfig, cache) {
+    this.client = new DxpClient(getConfig);
+    this.pages = new Pages(this.client, cache);
+    this.articles = new Articles(this.client, cache);
+    this.events = new Events(this.client, cache);
+    this.setttings = new Settings(this.client, cache);
+    this.tags = new Tags(this.client, cache);
+    this.redirects = new Redirects(this.client, cache);
+  }
+}

package/src/dxp/public/DxpClient.js

@@ -0,0 +1,40 @@
+import { gql, request } from "graphql-request";
+
+export default class DxpClient {
+  constructor(getConfig) {
+    this.getConfig = getConfig;
+    this.gql = gql;
+  }
+
+  _gqlRequest(url, query, variables = {}, headers = {}) {
+    return request({
+      url,
+      document: query,
+      variables: variables,
+      requestHeaders: headers,
+    });
+  }
+
+  async query(query, variables = {}, opts = {}) {
+    if (opts.withProxy) {
+      // TODO: Maybe the endpoint can be configurable?
+      return fetch("/api/data", {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify({ query, variables }),
+      }).then((r) => r.json());
+    }
+
+    return this._gqlRequest(
+      `${this.getConfig().cloud.gateway_url}/dispatch`,
+      query,
+      variables,
+      {
+        "x-raketa-project": this.getConfig().cloud.gateway_project,
+        "x-raketa-service": this.getConfig().cloud.dxp_service_public,
+      }
+    );
+  }
+}

package/src/dxp/public/DxpModel.js

@@ -0,0 +1,44 @@
+export default class DxpModel {
+  constructor(client, cache) {
+    this.client = client;
+    this.cache = cache;
+  }
+
+  async fetch(cacheKey, fetcher, opts = {}) {
+    if (opts.withCache && this.cache) {
+      return this.cache.fetch(cacheKey, fetcher);
+    } else {
+      return fetcher();
+    }
+  }
+
+  coercePageNumber(maybeNum) {
+    const parsed = Number.parseInt(maybeNum, 10);
+
+    if (Number.isNaN(parsed)) {
+      return 1;
+    }
+
+    if (parsed <= 0) {
+      return 1;
+    }
+
+    return parsed;
+  }
+
+  formatPaginationInInput(locale, input) {
+    if (input?.pagination?.page) {
+      return {
+        input: Object.assign({}, input, {
+          pagination: {
+            page: this.coercePageNumber(input.pagination?.page || 1),
+            pageSize: input.pagination?.pageSize || 12,
+          },
+          locale,
+        }),
+      };
+    } else {
+      return { input: { ...input, locale } };
+    }
+  }
+}

package/src/dxp/public/Events.js

@@ -0,0 +1,38 @@
+import DxpModel from "./DxpModel";
+import { EventBySlugDocument, EventsDocument } from "./documents";
+
+export default class Events extends DxpModel {
+  async find(locale, slug, opts = {}) {
+    const response = await this.fetch(
+      `event-${locale}-${slug}`,
+      async () =>
+        await this.client.query(
+          EventBySlugDocument,
+          {
+            input: {
+              locale,
+              slug,
+            },
+          },
+          opts
+        ),
+      opts
+    );
+
+    return response?.event;
+  }
+
+  async list(locale, input = {}, opts = {}) {
+    const response = await this.fetch(
+      `events-${locale}-${JSON.stringify(input)}`,
+      async () =>
+        await this.client.query(
+          EventsDocument,
+          this.formatPaginationInInput(locale, input),
+          opts
+        )
+    );
+
+    return response?.events;
+  }
+}

package/src/dxp/public/Pages.js

@@ -0,0 +1,38 @@
+import DxpModel from "./DxpModel";
+import { PageBySlugDocument, PagesDocument } from "./documents";
+
+export default class Pages extends DxpModel {
+  async find(locale, slug, opts = {}) {
+    const response = await this.fetch(
+      `page-${locale}-${slug}`,
+      async () =>
+        await this.client.query(
+          PageBySlugDocument,
+          {
+            input: {
+              locale,
+              slug,
+            },
+          },
+          opts
+        ),
+      opts
+    );
+
+    return response?.page;
+  }
+
+  async list(locale, input = {}, opts = {}) {
+    const response = await this.fetch(
+      `pages-${locale}-${JSON.stringify(input)}`,
+      async () =>
+        await this.client.query(
+          PagesDocument,
+          this.formatPaginationInInput(locale, input),
+          opts
+        )
+    );
+
+    return response?.pages;
+  }
+}

package/src/dxp/public/Redirects.js

@@ -0,0 +1,23 @@
+import DxpModel from "./DxpModel";
+import { RedirectDocument } from "./documents";
+
+export default class Redirects extends DxpModel {
+  async find(url, opts = {}) {
+    const response = await this.fetch(
+      `redirect-${url}`,
+      async () =>
+        await this.client.query(
+          RedirectDocument,
+          {
+            input: {
+              url,
+            },
+          },
+          opts
+        ),
+      opts
+    );
+
+    return response?.redirect;
+  }
+}

package/src/dxp/public/Settings.js

@@ -0,0 +1,21 @@
+import DxpModel from "./DxpModel";
+import { SettingDocument } from "./documents";
+
+export default class Settings extends DxpModel {
+  async find(locale, opts = {}) {
+    const response = await this.fetch(
+      `website-settings-${locale}`,
+      async () =>
+        await this.client.query(
+          SettingDocument,
+          {
+            locale,
+          },
+          opts
+        ),
+      opts
+    );
+
+    return response?.setting;
+  }
+}

package/src/dxp/public/Tags.js

@@ -0,0 +1,24 @@
+import DxpModel from "./DxpModel";
+import { TagBySlugDocument } from "./documents";
+
+export default class Tags extends DxpModel {
+  async find(locale, slug, opts = {}) {
+    const response = await this.fetch(
+      `tag-${locale}-${slug}`,
+      async () =>
+        await this.client.query(
+          TagBySlugDocument,
+          {
+            input: {
+              locale,
+              slug,
+            },
+          },
+          opts
+        ),
+      opts
+    );
+
+    return response?.tag;
+  }
+}

package/src/dxp/public/documents.js

@@ -0,0 +1,299 @@
+import { gql } from "../graphql";
+
+function tagFragment() {
+  return gql`
+    {
+      id
+      name
+      slug
+    }
+  `;
+}
+
+function revisionFragment() {
+  return gql`
+    {
+      id
+      title
+      slug
+      settings
+      widgets
+      visibility
+    }
+  `;
+}
+
+function paginationFragment() {
+  return gql`
+    {
+      currentPage
+      pagesCount
+      entriesCount
+      pageSize
+    }
+  `;
+}
+
+function resourceTypeFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+    }
+  `;
+}
+
+function categoryFragment() {
+  return gql`
+    {
+      type
+      slug
+      name
+      settings
+    }
+  `;
+}
+
+const CategoriesDocument = gql`
+  query Categories($input: CategoriesInput!) {
+    categories(input: $input) {
+      list ${categoryFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const ArticlesDocument = gql`
+  query Articles($input: ArticlesInput!) {
+    articles(input: $input) {
+      list {
+        id
+        slug
+        title
+        widgets
+        settings
+        publishAt
+        visibility
+        tags ${tagFragment()}
+        categories ${categoryFragment()}
+        articleType ${resourceTypeFragment()}
+      }
+
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const PageBySlugDocument = gql`
+  query PageBySlug($input: SlugInput!) {
+    page(input: $input) {
+      id
+      title
+      slug
+      settings
+      widgets
+      websiteSettings
+      createdAt
+      updatedAt
+      visibility
+      translations
+      pageType ${resourceTypeFragment()}
+      categories ${categoryFragment()}
+      tags ${tagFragment()}
+    }
+  }
+`;
+
+const PageRevisionPreviewDocument = gql`
+  query ($input: RevisionPreviewInput!) {
+    pageRevisionPreview(input: $input) {
+      page {
+        id
+        title
+        slug
+        settings
+        widgets
+        websiteSettings
+        createdAt
+        updatedAt
+        visibility
+        translations
+        pageType ${resourceTypeFragment()}
+        categories ${categoryFragment()}
+        tags ${tagFragment()}
+      }
+      revision ${revisionFragment()}
+    }
+  }
+`;
+
+const PagesDocument = gql`
+  query Pages($input: PagesInput!) {
+    pages(input: $input) {
+      list {
+        id
+        slug
+        title
+        widgets
+        settings
+        visibility
+        pageType ${resourceTypeFragment()}
+        categories ${categoryFragment()}
+        tags ${tagFragment()}
+      }
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const ArticleBySlugDocument = gql`
+  query ArticleBySlug($input: SlugInput!) {
+    article(input: $input) {
+      id
+      title
+      slug
+      settings
+      widgets
+      publishAt
+      updatedAt
+      websiteSettings
+      visibility
+      translations
+      articleType ${resourceTypeFragment()}
+      categories ${categoryFragment()}
+      tags ${tagFragment()}
+    }
+  }
+`;
+
+const ArticleRevisionPreviewDocument = gql`
+  query ($input: RevisionPreviewInput!) {
+    articleRevisionPreview(input: $input) {
+      article {
+        id
+        title
+        slug
+        settings
+        widgets
+        publishAt
+        websiteSettings
+        visibility
+        translations
+        articleType ${resourceTypeFragment()}
+        categories ${categoryFragment()}
+        tags ${tagFragment()}
+      }
+      revision ${revisionFragment()}
+    }
+  }
+`;
+
+const SettingDocument = gql`
+  query Setting($locale: String!) {
+    setting(locale: $locale) {
+      value
+    }
+  }
+`;
+
+const TagBySlugDocument = gql`
+  query TagBySlug($input: SlugInput!) {
+    tag(input: $input) {
+      name
+      slug
+    }
+  }
+`;
+
+const EventsDocument = gql`
+  query Events($input: EventsInput!) {
+    events(input: $input) {
+      list {
+        id
+        slug
+        title
+        widgets
+        settings
+        publishAt
+        startsAt
+        endsAt
+        visibility
+        eventType ${resourceTypeFragment()}
+        categories ${categoryFragment()}
+        tags ${tagFragment()}
+      }
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const EventBySlugDocument = gql`
+  query EventBySlug($input: SlugInput!) {
+    event(input: $input) {
+      id
+      title
+      slug
+      settings
+      widgets
+      publishAt
+      startsAt
+      endsAt
+      websiteSettings
+      visibility
+      translations
+      eventType ${resourceTypeFragment()}
+      categories ${categoryFragment()}
+      tags ${tagFragment()}
+    }
+  }
+`;
+
+const EventRevisionPreviewDocument = gql`
+  query ($input: RevisionPreviewInput!) {
+    eventRevisionPreview(input: $input) {
+      event {
+        id
+        title
+        slug
+        settings
+        widgets
+        publishAt
+        websiteSettings
+        visibility
+        translations
+        eventType ${resourceTypeFragment()}
+        categories ${categoryFragment()}
+        tags ${tagFragment()}
+      }
+      revision ${revisionFragment()}
+    }
+  }
+`;
+
+const RedirectDocument = gql`
+  query ($input: UrlInput!) {
+    redirect(input: $input) {
+      id
+      url
+      destination
+      httpResponseCode
+    }
+  }
+`;
+
+export {
+  ArticlesDocument,
+  ArticleBySlugDocument,
+  ArticleRevisionPreviewDocument,
+  PagesDocument,
+  PageBySlugDocument,
+  PageRevisionPreviewDocument,
+  EventsDocument,
+  EventBySlugDocument,
+  EventRevisionPreviewDocument,
+  SettingDocument,
+  CategoriesDocument,
+  TagBySlugDocument,
+  RedirectDocument,
+};

package/src/dxp/public/index.js

@@ -0,0 +1,3 @@
+import Dxp from "./Dxp";
+
+export default Dxp;

package/src/index.js

@@ -0,0 +1,4 @@
+export { default as Cache } from "./Cache";
+export { default as DxpPublic } from "./dxp/public";
+export { default as DxpPrivate } from "./dxp/private";
+export { default as generateCloudPublicHelpers } from "./cloud/public";

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@repo/typescript-config/react-library.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}