@pronto-tools-and-more/api 12.35.1

package/src/parts/HandleApiAppSettings/HandleApiAppSettings.js

@@ -0,0 +1,41 @@
+import * as GraphQlQueryAppSettings from "../GraphQlQueryAppSettings/GraphQlQueryAppSettings.js";
+
+export const handleApiAppSettings = async ({ appId, apiUrl, req }) => {
+  const realBottom = {
+    ...GraphQlQueryAppSettings.bottom,
+    filter: {},
+    appInfo: {
+      ...GraphQlQueryAppSettings.bottom.appInfo,
+      appId,
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: GraphQlQueryAppSettings.queryName,
+      query: GraphQlQueryAppSettings.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+
+  // @ts-ignore
+  const realData = result.data.catalog.appSettingsConnection.edges
+    .map((edge) => edge.node)
+    .map((node) => {
+      const { __typename, ...rest } = node;
+      return rest;
+    });
+
+  return {
+    headers: {
+      "content-type": "application/json",
+    },
+    status: 200,
+    body: JSON.stringify(realData, null, 2),
+  };
+};

package/src/parts/HandleApiArticle/HandleApiArticle.js

@@ -0,0 +1,26 @@
+import * as GetPostIds from "../GetPostIds/GetPostIds.js";
+import * as HandleApiPostByName from "../HandleApiPostByName/HandleApiPostByName.js";
+import * as HandleApiArticleByCategoryId from "../HandleApiArticleByCategoryId/HandleApiArticleByCategoryId.js";
+
+export const handleApiArticle = async ({ appId, apiUrl, req }) => {
+  const articleSlug = req.url.slice("/articles/".length);
+  const url = new URL(req.url, "https://example.com");
+  const categoryId = url.searchParams.get("categoryId");
+  if (categoryId) {
+    return HandleApiArticleByCategoryId.handleApiArticleByCategoryId({
+      apiUrl,
+      appId,
+      categoryId,
+    });
+  }
+  const postIds = await GetPostIds.getPostIds({
+    appId,
+    apiUrl,
+    slug: articleSlug,
+  });
+  return HandleApiPostByName.handleApiPostByName({
+    apiUrl,
+    appId,
+    postIds,
+  });
+};

package/src/parts/HandleApiArticleByCategoryId/HandleApiArticleByCategoryId.js

@@ -0,0 +1,97 @@
+import * as GraphQlQueryContent from "../GraphQlQueryContent/GraphQlQueryContent.js";
+
+const getContent = async ({ appId, apiUrl, categoryId }) => {
+  const realBottom = {
+    ...GraphQlQueryContent.bottom,
+    appInfo: {
+      ...GraphQlQueryContent.bottom.appInfo,
+      appId,
+    },
+    filter: {
+      AND: [
+        {
+          contentType: {
+            value: "POST",
+          },
+        },
+        {
+          postType: {
+            value: "post",
+          },
+        },
+        {
+          taxonomies: {
+            content: {
+              value: {
+                AND: [
+                  {
+                    type: {
+                      value: "category",
+                    },
+                  },
+                  {
+                    OR: [
+                      {
+                        id: {
+                          value: categoryId,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          },
+        },
+        {
+          id: {
+            value: "^()$",
+            operation: "REGEX",
+            negated: true,
+          },
+        },
+      ],
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: GraphQlQueryContent.queryName,
+      query: GraphQlQueryContent.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  if (result && result.error) {
+    // @ts-ignore
+    throw new Error(`api error: ${result.error}`);
+  }
+  // @ts-ignore
+  const realData = result.data.catalog.contentsConnection.edges
+    .map((edge) => edge.content)
+    .map((match) => {
+      const { __typename, ...rest } = match;
+      return rest;
+    });
+  return realData;
+};
+
+export const handleApiArticleByCategoryId = async ({
+  appId,
+  apiUrl,
+  categoryId,
+}) => {
+  const content = await getContent({ appId, apiUrl, categoryId });
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(content, null, 2),
+  };
+};

package/src/parts/HandleApiAuthors/HandleApiAuthors.js

@@ -0,0 +1,38 @@
+import * as GraphQlQueryAuthors from "../GraphQlQueryAuthors/GraphQlQueryAuthors.js";
+
+export const handleAuthors = async ({ appId, apiUrl, req }) => {
+  const realBottom = {
+    ...GraphQlQueryAuthors.bottom,
+    appInfo: {
+      ...GraphQlQueryAuthors.bottom.appInfo,
+      appId,
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: "CatalogContentsQuery",
+      query: GraphQlQueryAuthors.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  const realData = result.data.catalog.taxonomiesConnection.edges
+    .map((edge) => edge.node)
+    .map((node) => {
+      const { __typename, ...rest } = node;
+      return rest;
+    });
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(realData, null, 2),
+  };
+};

package/src/parts/HandleApiCategories/HandleApiCategories.js

@@ -0,0 +1,38 @@
+import * as GraphQlQueryCategories from "../GraphQlQueryCategories/GraphQlQueryCategories.js";
+
+export const handleCategories = async ({ appId, apiUrl, req }) => {
+  const realBottom = {
+    ...GraphQlQueryCategories.bottom,
+    appInfo: {
+      ...GraphQlQueryCategories.bottom.appInfo,
+      appId,
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: "CatalogContentsQuery",
+      query: GraphQlQueryCategories.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  const realData = result.data.catalog.taxonomiesConnection.edges
+    .map((edge) => edge.node)
+    .map((node) => {
+      const { __typename, ...rest } = node;
+      return rest;
+    });
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(realData, null, 2),
+  };
+};

package/src/parts/HandleApiCollection/HandleApiCollection.js

@@ -0,0 +1,62 @@
+import * as GraphQlQueryCollection from "../GraphQlQueryCollection/GraphQlQueryCollection.js";
+
+const getCollections = async ({ appId, apiUrl, name }) => {
+  const realBottom = {
+    ...GraphQlQueryCollection.bottom,
+    appInfo: {
+      ...GraphQlQueryCollection.bottom.appInfo,
+      appId,
+    },
+    filter: {
+      name: {
+        value: name,
+      },
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: GraphQlQueryCollection.queryName,
+      query: GraphQlQueryCollection.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  if (result && result.error) {
+    // @ts-ignore
+    throw new Error(`api error: ${result.error}`);
+  }
+  // @ts-ignore
+  if (result && result.errors) {
+    // @ts-ignore
+    throw new Error(`api error: ${result.errors[0].message}`);
+  }
+  console.log({ result });
+  // @ts-ignore
+  const realData = result.data.catalog.collectionsConnection.edges
+    .map((edge) => {
+      return edge.node;
+    })
+    .map((match) => {
+      const { __typename, ...rest } = match;
+      return rest;
+    });
+  return realData;
+};
+
+export const handleApiCollection = async ({ appId, apiUrl, req }) => {
+  const name = req.url.slice("/collections/".length);
+  const content = await getCollections({ appId, apiUrl, name });
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(content, null, 2),
+  };
+};

package/src/parts/HandleApiCollections/HandleApiCollections.js

@@ -0,0 +1,52 @@
+import * as GraphQlQueryCollections from "../GraphQlQueryCollections/GraphQlQueryCollections.js";
+
+const getCollections = async ({ appId, apiUrl }) => {
+  const realBottom = {
+    ...GraphQlQueryCollections.bottom,
+    appInfo: {
+      ...GraphQlQueryCollections.bottom.appInfo,
+      appId,
+    },
+    filter: {},
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: GraphQlQueryCollections.queryName,
+      query: GraphQlQueryCollections.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  if (result && result.error) {
+    // @ts-ignore
+    throw new Error(`api error: ${result.error}`);
+  }
+  // @ts-ignore
+  const realData = result.data.catalog.collectionsConnection.edges
+    .map((edge) => {
+      return edge.node;
+    })
+    .map((match) => {
+      const { __typename, ...rest } = match;
+      return rest;
+    });
+  return realData;
+};
+
+export const handleApiCollections = async ({ appId, apiUrl, req }) => {
+  const content = await getCollections({ appId, apiUrl });
+  console.log({ content });
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(content, null, 2),
+  };
+};

package/src/parts/HandleApiDossier/HandleApiDossier.js

@@ -0,0 +1,109 @@
+import * as GraphQlQueryPathSegment from "../GraphQlQueryPathSegment/GraphQlQueryPathSegment.js";
+import * as GraphQlQueryDossier from "../GraphQlQueryDossier/GraphQlQueryDossier.js";
+
+const getBundleId = async ({ appId, reqUrl }) => {
+  const url = `https://catalog.purplemanager.com/graphql`;
+  const part = reqUrl.slice("/dossiers".length + 1);
+  const realBottom = {
+    ...GraphQlQueryPathSegment.bottom1,
+    appInfo: {
+      ...GraphQlQueryPathSegment.bottom1.appInfo,
+      appId,
+    },
+    pathSegments: [part],
+  };
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: "LookupPathSegmentsQuery",
+      query: GraphQlQueryPathSegment.top1,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  const items = result.data.catalog.lookupPathSegments.flatMap(
+    (item) => item.matches
+  );
+  if (items.length === 0) {
+    return "";
+  }
+  const id = items[0].id;
+  return id;
+};
+
+export const handleDossier = async ({ appId, apiUrl, req }) => {
+  const bundleId = await getBundleId({
+    appId,
+    reqUrl: req.url,
+  });
+  if (!bundleId) {
+    return {
+      status: 404,
+      headers: {},
+      body: "Not found",
+    };
+  }
+  const realBottom = {
+    ...GraphQlQueryDossier.bottom1,
+    appInfo: {
+      ...GraphQlQueryDossier.bottom1.appInfo,
+      appId,
+    },
+    filter: {
+      AND: [
+        {
+          postType: {
+            value: "post",
+          },
+        },
+        {
+          contentType: {
+            value: "POST",
+          },
+        },
+        {
+          AND: [
+            {
+              bundleId: {
+                value: bundleId,
+              },
+            },
+          ],
+        },
+      ],
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: "CatalogContentsQuery",
+      query: GraphQlQueryDossier.top1,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  const realData = result.data.catalog.contentsConnection.edges
+    .map((edge) => edge.content)
+    .map((node) => {
+      const { __typename, ...rest } = node;
+      return rest;
+    });
+
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(realData, null, 2),
+  };
+};

package/src/parts/HandleApiDossiers/HandleApiDossiers.js

@@ -0,0 +1,39 @@
+import * as GraphQlQueryDossiers from "../GraphQlQueryDossiers/GraphQlQueryDossiers.js";
+
+export const handleDossiers = async ({ appId, apiUrl, req }) => {
+  const realBottom = {
+    ...GraphQlQueryDossiers.bottom,
+    appInfo: {
+      ...GraphQlQueryDossiers.bottom.appInfo,
+      appId,
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: "CatalogContentsQuery",
+      query: GraphQlQueryDossiers.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  const realData = result.data.catalog.contentsConnection.edges
+    .map((edge) => edge.content)
+    .map((node) => {
+      const { __typename, ...rest } = node;
+      return rest;
+    });
+
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(realData, null, 2),
+  };
+};

package/src/parts/HandleApiIndex/HandleApiIndex.js

@@ -0,0 +1,30 @@
+export const handleIndex = async (req, res, next) => {
+  const html = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Api</title>
+  </head>
+  <body>
+    <ul>
+      <li><a href="/api/issues">Issues</a></li>
+      <li><a href="/api/dossiers">Dossiers</a></li>
+      <li><a href="/api/categories">Categories</a></li>
+      <li><a href="/api/articles">Articles</a></li>
+      <li><a href="/api/authors">Authors</a></li>
+      <li><a href="/api/collections">Collections</a></li>
+      <li><a href="/api/menus">Menus</a></li>
+      <li><a href="/api/appSettings">App Settings</a></li>
+    </ul>
+  </body>
+</html>
+`;
+  return {
+    body: html,
+    status: 200,
+    headers: {
+      "content-type": "text.html",
+    },
+  };
+};

package/src/parts/HandleApiIssues/HandleApiIssues.js

@@ -0,0 +1,39 @@
+import * as GraphQlQueryIssues from "../GraphQlQueryIssues/GraphQlQueryIssues.js";
+
+export const handleIssues = async ({ appId, apiUrl, req }) => {
+  const realBottom = {
+    ...GraphQlQueryIssues.bottom,
+    appInfo: {
+      ...GraphQlQueryIssues.bottom.appInfo,
+      appId,
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: "CatalogContentsQuery",
+      query: GraphQlQueryIssues.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  const realData = result.data.catalog.contentsConnection.edges
+    .map((edge) => edge.content)
+    .map((node) => {
+      const { __typename, ...rest } = node;
+      return rest;
+    });
+
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(realData, null, 2),
+  };
+};

package/src/parts/HandleApiMenus/HandleApiMenus.js

@@ -0,0 +1,40 @@
+import * as GraphQlQueryMenus from "../GraphQlQueryMenus/GraphQlQueryMenus.js";
+
+export const handleMenus = async ({ appId, apiUrl, req }) => {
+  const realBottom = {
+    ...GraphQlQueryMenus.bottom,
+    filter: {},
+    appInfo: {
+      ...GraphQlQueryMenus.bottom.appInfo,
+      appId,
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: GraphQlQueryMenus.queryName,
+      query: GraphQlQueryMenus.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  const realData = result.data.catalog.menusConnection.edges
+    .map((edge) => edge.content)
+    .map((node) => {
+      const { __typename, ...rest } = node;
+      return rest;
+    });
+
+  return {
+    headers: {
+      "content-type": "application/json",
+    },
+    status: 200,
+    body: JSON.stringify(realData, null, 2),
+  };
+};

package/src/parts/HandleApiPostByName/HandleApiPostByName.js

@@ -0,0 +1,63 @@
+import * as GraphQlQueryContent from "../GraphQlQueryContent/GraphQlQueryContent.js";
+
+const getContent = async ({ appId, apiUrl, postId }) => {
+  const realBottom = {
+    ...GraphQlQueryContent.bottom,
+    appInfo: {
+      ...GraphQlQueryContent.bottom.appInfo,
+      appId,
+    },
+    filter: {
+      id: {
+        value: postId,
+      },
+    },
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      operationName: GraphQlQueryContent.queryName,
+      query: GraphQlQueryContent.top,
+      variables: realBottom,
+    }),
+  });
+  const result = await response.json();
+  // @ts-ignore
+  if (result && result.error) {
+    // @ts-ignore
+    throw new Error(`api error: ${result.error}`);
+  }
+  // @ts-ignore
+  const realData = result.data.catalog.contentsConnection.edges
+    .map((edge) => edge.content)
+    .map((match) => {
+      const { __typename, ...rest } = match;
+      return rest;
+    });
+  return realData;
+};
+
+export const handleApiPostByName = async ({ postIds, appId, apiUrl }) => {
+  if (postIds.length === 0) {
+    return {
+      status: 404,
+      headers: {
+        "content-type": "application/json",
+      },
+      body: JSON.stringify("Not found", null, 2),
+    };
+  }
+  const postId = postIds[0];
+  const content = await getContent({ appId, apiUrl, postId });
+  return {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(content, null, 2),
+  };
+};

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,10 @@
+import * as HandleMessage from "../HandleMessage/HandleMessage.js";
+
+export const handleIpc = (ipc) => {
+  if ("addEventListener" in ipc) {
+    ipc.addEventListener("message", HandleMessage.handleMessage);
+  } else if ("on" in ipc) {
+    // deprecated
+    ipc.on("message", HandleMessage.handleMessage);
+  }
+};