@alphasquad/saleor-template-advance 0.1.0

package/src/graphql/queries/getNewsletter.ts

@@ -0,0 +1,122 @@
+import { gql } from "@apollo/client";
+import createApolloServerClient from "../server-client";
+
+export const GET_NEWSLETTER = gql`
+  query Contact($first: Int = 1) {
+    pages(first: $first, filter: { slugs: "newsletter-signup" }) {
+      edges {
+        node {
+          id
+          title
+          content
+          isPublished
+          metadata {
+            key
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+
+export type NEWSLETTERMetadata = {
+  key: string;
+  value: string;
+};
+
+export type NewsletterPageNode = {
+  id: string;
+  title: string;
+  content: string | null;
+  isPublished: boolean;
+  metadata: NEWSLETTERMetadata[];
+};
+
+export type NewsletterPageEdge = {
+  node: NewsletterPageNode;
+};
+
+export type NewsletterPageResponse = {
+  pages: {
+    edges: NewsletterPageEdge[];
+  };
+};
+
+export type NewsLetterPageData = {
+  id: string;
+  title: string;
+  content: string | null;
+  contactFormEnabled: boolean;
+  isPublished: boolean;
+  productInquiryFormEnabled: boolean;
+  recaptchaEnabled: boolean;
+  fields: string[];
+  description: string | null;
+  emailTo: string | null;
+  emailCc: string | null;
+  emailBcc: string | null;
+  emailSubject: string | null;
+  successMessage: string | null;
+};
+
+export function parseContactPageMetadata(node: NewsletterPageNode): NewsLetterPageData {
+  const metadata = node.metadata.reduce((acc, item) => {
+    acc[item.key] = item.value;
+    return acc;
+  }, {} as Record<string, string>);
+  return {
+    id: node.id,
+    title: node.title,
+    content: node.content,
+    contactFormEnabled: metadata.contact_form === "true",
+    isPublished: node.isPublished,
+    productInquiryFormEnabled: metadata.product_inquiry_form === "true",
+    recaptchaEnabled: metadata.reCAPTCHA === "true",
+    fields: metadata.fields
+      ? metadata.fields.split(",").map((f) => f.trim())
+      : [],
+    description: metadata.description || null,
+    emailTo: metadata.email_to || null,
+    emailCc: metadata.email_cc || null,
+    emailBcc: metadata.email_bcc || null,
+    emailSubject: metadata.email_subject || null,
+    successMessage: metadata.success_message || null,
+  };
+}
+
+export async function fetchContactPage(): Promise<NewsLetterPageData | null> {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping contact page fetch");
+    return null;
+  }
+
+  try {
+    const client = createApolloServerClient();
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Contact page fetch timeout")), 5000)
+    );
+
+    const queryPromise = client.query<NewsletterPageResponse>({
+      query: GET_NEWSLETTER,
+      variables: { first: 1 },
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    });
+
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    const edges = result?.data?.pages?.edges;
+
+    if (edges && edges.length > 0) {
+      return parseContactPageMetadata(edges[0].node);
+    }
+
+    return null;
+  } catch (err) {
+    console.warn(
+      "Failed to fetch contact page:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+    return null;
+  }
+}

package/src/graphql/queries/getNewsletterPage.ts

@@ -0,0 +1,111 @@
+import { gql } from "@apollo/client";
+import createApolloServerClient from "../server-client";
+
+export const GET_NEWSLETTER_PAGE = gql`
+  query Newsletter($first: Int = 1) {
+    pages(first: $first, filter: { slugs: "newsletter-signup" }) {
+      edges {
+        node {
+          id
+          title
+          content
+          metadata {
+            key
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+
+export type NewsletterMetadata = {
+  key: string;
+  value: string;
+};
+
+export type NewsletterPageNode = {
+  id: string;
+  title: string;
+  content: string | null;
+  metadata: NewsletterMetadata[];
+};
+
+export type NewsletterPageEdge = {
+  node: NewsletterPageNode;
+};
+
+export type NewsletterPageResponse = {
+  pages: {
+    edges: NewsletterPageEdge[];
+  };
+};
+
+export type NewsletterPageData = {
+  id: string;
+  title: string;
+  content: string | null;
+  description: string | null;
+  emailTo: string | null;
+  emailCc: string | null;
+  emailBcc: string | null;
+  emailSubject: string | null;
+  successMessage: string | null;
+};
+
+export function parseNewsletterPageMetadata(
+  node: NewsletterPageNode
+): NewsletterPageData {
+  const metadata = node.metadata.reduce((acc, item) => {
+    acc[item.key] = item.value;
+    return acc;
+  }, {} as Record<string, string>);
+
+  return {
+    id: node.id,
+    title: node.title,
+    content: node.content,
+    description: metadata.description || null,
+    emailTo: metadata.email_to || null,
+    emailCc: metadata.email_cc || null,
+    emailBcc: metadata.email_bcc || null,
+    emailSubject: metadata.email_subject || null,
+    successMessage: metadata.success_message || null,
+  };
+}
+
+export async function fetchNewsletterPage(): Promise<NewsletterPageData | null> {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping newsletter page fetch");
+    return null;
+  }
+
+  try {
+    const client = createApolloServerClient();
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Newsletter page fetch timeout")), 5000)
+    );
+
+    const queryPromise = client.query<NewsletterPageResponse>({
+      query: GET_NEWSLETTER_PAGE,
+      variables: { first: 1 },
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    });
+
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    const edges = result?.data?.pages?.edges;
+
+    if (edges && edges.length > 0) {
+      return parseNewsletterPageMetadata(edges[0].node);
+    }
+
+    return null;
+  } catch (err) {
+    console.warn(
+      "Failed to fetch newsletter page:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+    return null;
+  }
+}

package/src/graphql/queries/getPageBySlug.ts

@@ -0,0 +1,52 @@
+import { gql } from "@apollo/client"
+import createApolloServerClient from "../server-client"
+
+export const GET_PAGE_BY_SLUG = gql`
+  query PageBySlug($slug: String!) {
+    page(slug: $slug) {
+      id
+      seoTitle
+      seoDescription
+      content
+    }
+  }
+`
+
+export type AncillaryPage = {
+  id: string
+  seoTitle: string | null
+  seoDescription: string | null
+  content: string | null
+}
+
+type PageBySlugResponse = { page: AncillaryPage | null }
+
+export async function fetchPageBySlug(slug: string): Promise<AncillaryPage | null> {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping page fetch")
+    return null
+  }
+
+  try {
+    const client = createApolloServerClient()
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Page fetch timeout")), 5000)
+    )
+
+    const queryPromise = client.query<PageBySlugResponse>({
+      query: GET_PAGE_BY_SLUG,
+      variables: { slug },
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    })
+
+    const result = await Promise.race([queryPromise, timeoutPromise])
+    return result?.data?.page ?? null
+  } catch (err) {
+    console.warn(
+      "Failed to fetch page by slug:",
+      err instanceof Error ? err.message : "Unknown error"
+    )
+    return null
+  }
+}

package/src/graphql/queries/getPageTypeId.ts

@@ -0,0 +1,27 @@
+import { gql } from "@apollo/client"
+
+export const GET_TESTIMONIAL_PAGE_TYPE = gql`
+  query PageTypeList {
+    pageTypes(first: 100, filter: { slugs: "testimonial" }) {
+      edges {
+        node {
+          id
+          slug
+        }
+      }
+    }
+  }
+`
+
+export const GET_PROMOTION_PAGE_TYPE = gql`
+  query PageTypeList {
+    pageTypes(first: 100, filter: { slugs: "promotion" }) {
+      edges {
+        node {
+          id
+          slug
+        }
+      }
+    }
+  }
+`

package/src/graphql/queries/getPaymentMethods.ts

@@ -0,0 +1,61 @@
+import { gql } from "@apollo/client";
+import createApolloServerClient from "../server-client";
+
+// GraphQL: fetch a single page by slug that includes metadata key/value pairs
+const GET_PAYMENT_METHODS = gql`
+  query PaymentMethods {
+    page(slug: "payment-methods") {
+      id
+      metadata {
+        key
+        value
+      }
+    }
+  }
+`;
+
+export type PaymentMethodFlagKey =
+  | "VISA"
+  | "MasterCard"
+  | "Amex"
+  | "PayPal"
+  | "GooglePay"
+  | "ApplePay";
+
+export type PaymentMethodsResponse = {
+  page: {
+    id: string;
+    metadata: { key: PaymentMethodFlagKey; value: string }[];
+  } | null;
+};
+
+export const fetchPaymentMethods = async () => {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    // Same behavior as other fetchers: be tolerant when API is not configured
+    console.warn("API URL not configured, skipping payment methods fetch");
+    return null as PaymentMethodsResponse["page"];
+  }
+
+  try {
+    const client = createApolloServerClient();
+
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Payment methods fetch timeout")), 5000)
+    );
+
+    const queryPromise = client.query<{ page: PaymentMethodsResponse["page"]}>({
+      query: GET_PAYMENT_METHODS,
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    });
+
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    return result?.data?.page ?? null;
+  } catch (err) {
+    console.warn(
+      "Failed to fetch payment methods:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+    return null;
+  }
+};

package/src/graphql/queries/getProducts.ts

@@ -0,0 +1,78 @@
+import { gql } from "@apollo/client";
+
+export const GET_PRODUCTS = gql`
+  query GetProducts(
+    $channel: String!
+    $first: Int!
+    $after: String
+    $categoryIds: [ID!]
+    $search: String
+  ) {
+    products(
+      filter: { categories: $categoryIds, search: $search }
+      channel: $channel
+      first: $first
+      after: $after
+    ) {
+      totalCount
+      pageInfo {
+        hasNextPage
+        hasPreviousPage
+        startCursor
+        endCursor
+      }
+      edges {
+        node {
+          id
+          name
+          slug
+          media { id url alt }
+          category { id name }
+          pricing {
+            onSale
+            priceRange {
+              start { gross { amount currency } }
+              stop { gross { amount currency } }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+export interface GetProductsData {
+  products: {
+    totalCount: number;
+    pageInfo: {
+      hasNextPage: boolean;
+      hasPreviousPage: boolean;
+      startCursor: string | null;
+      endCursor: string | null;
+    };
+    edges: Array<{
+      node: {
+        id: string;
+        name: string;
+        slug: string;
+        media: Array<{ id: string; url: string; alt: string | null }>;
+        category: { id: string; name: string } | null;
+        pricing: {
+          onSale: boolean | null;
+          priceRange: {
+            start: { gross: { amount: number; currency: string } } | null;
+            stop: { gross: { amount: number; currency: string } } | null;
+          } | null;
+        } | null;
+      };
+    }>;
+  };
+}
+
+export interface GetProductsVars {
+  channel: string;
+  first: number;
+  after?: string | null;
+  categoryIds?: string[];
+  search?: string;
+}

package/src/graphql/queries/getPromotions.ts

@@ -0,0 +1,24 @@
+import { gql } from "@apollo/client"
+
+export const GET_PROMOTIONS = gql`
+  query Promotions($pageTypeId: ID!, $first: Int = 100, $after: String) {
+    pages(
+      first: $first
+      after: $after
+      filter: { pageTypes: [$pageTypeId] }
+      sortBy: { field: PUBLICATION_DATE, direction: DESC }
+    ) {
+      edges {
+        node {
+          id
+          title
+          content
+          metadata {
+            key
+            value
+          }
+        }
+      }
+    }
+  }
+`

package/src/graphql/queries/getRequestReturnPage.ts

@@ -0,0 +1,121 @@
+import { gql } from "@apollo/client";
+import createApolloServerClient from "../server-client";
+
+export const GET_REQUEST_RETURN_PAGE = gql`
+  query Contact($first: Int = 1) {
+    pages(first: $first, filter: { slugs: "rma-request" }) {
+      edges {
+        node {
+          id
+          title
+          content
+          isPublished
+          metadata {
+            key
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+
+export type RequestReturnMetadata = {
+  key: string;
+  value: string;
+};
+
+export type RequestReturnPageNode = {
+  id: string;
+  title: string;
+  content: string | null;
+  isPublished: boolean;
+  metadata: RequestReturnMetadata[];
+};
+
+export type RequestReturnPageEdge = {
+  node: RequestReturnPageNode;
+};
+
+export type RequestReturnPageResponse = {
+  pages: {
+    edges: RequestReturnPageEdge[];
+  };
+};
+
+export type ReturnsPageData = {
+  id: string;
+  title: string;
+  content: string | null;
+  isPublished: boolean;
+  productInquiryFormEnabled: boolean;
+  recaptchaEnabled: boolean;
+  fields: string[];
+  description: string | null;
+  emailTo: string | null;
+  emailCc: string | null;
+  emailBcc: string | null;
+  emailSubject: string | null;
+  successMessage: string | null;
+};
+
+export function parseRequestReturnPageMetadata(
+  node: RequestReturnPageNode
+): ReturnsPageData {
+  const metadata = node.metadata.reduce((acc, item) => {
+    acc[item.key] = item.value;
+    return acc;
+  }, {} as Record<string, string>);
+
+  return {
+    id: node.id,
+    title: node.title,
+    content: node.content,
+    isPublished: node.isPublished,
+    productInquiryFormEnabled: metadata.product_inquiry_form === "true",
+    recaptchaEnabled: metadata.reCAPTCHA === "true",
+    fields: metadata.fields ? metadata.fields.split(",").map((f) => f.trim()) : [],
+    description: metadata.description || null,
+    emailTo: metadata.email_to || null,
+    emailCc: metadata.email_cc || null,
+    emailBcc: metadata.email_bcc || null,
+    emailSubject: metadata.email_subject || null,
+    successMessage: metadata.success_message || null,
+  };
+}
+
+export async function fetchContactPage(): Promise<ReturnsPageData | null> {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping contact page fetch");
+    return null;
+  }
+
+  try {
+    const client = createApolloServerClient();
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Contact page fetch timeout")), 5000)
+    );
+
+    const queryPromise = client.query<RequestReturnPageResponse>({
+      query: GET_REQUEST_RETURN_PAGE,
+      variables: { first: 1 },
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    });
+
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    const edges = result?.data?.pages?.edges;
+
+    if (edges && edges.length > 0) {
+      return parseRequestReturnPageMetadata(edges[0].node);
+    }
+
+    return null;
+  } catch (err) {
+    console.warn(
+      "Failed to fetch contact page:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+    return null;
+  }
+}

package/src/graphql/queries/getSiteInfo.ts

@@ -0,0 +1,54 @@
+import { gql } from "@apollo/client";
+import createApolloServerClient from "../server-client";
+
+const GET_SITE_INFO = gql`
+  query SiteInfo {
+    page(slug: "site-info") {
+      id
+      content
+      metadata {
+        key
+        value
+      }
+    }
+  }
+`;
+
+export type SiteInfoKey = "Address" | "Email" | "Phone" | "Timings";
+
+export type SiteInfoResponse = {
+  page: {
+    id: string;
+    content: string;
+    metadata: { key: SiteInfoKey; value: string }[];
+  } | null;
+};
+
+export const fetchSiteInfo = async () => {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping site info fetch");
+    return null as SiteInfoResponse["page"];
+  }
+
+  try {
+    const client = createApolloServerClient();
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Site info fetch timeout")), 5000)
+    );
+
+    const queryPromise = client.query<{ page: SiteInfoResponse["page"]}>({
+      query: GET_SITE_INFO,
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    });
+
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    return result?.data?.page ?? null;
+  } catch (err) {
+    console.warn(
+      "Failed to fetch site info:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+    return null;
+  }
+};

package/src/graphql/queries/getSocialLinks.ts

@@ -0,0 +1,52 @@
+import { gql } from "@apollo/client";
+import createApolloServerClient from "../server-client";
+
+const GET_SOCIAL_LINKS = gql`
+  query SocialMediaLinks {
+    page(slug: "social-media-links") {
+      id
+      metadata {
+        key
+        value
+      }
+    }
+  }
+`;
+
+export type SocialKey = "facebook" | "instagram" | "twitter" | "youtube";
+
+export type SocialLinksResponse = {
+  page: {
+    id: string;
+    metadata: { key: SocialKey; value: string }[];
+  } | null;
+};
+
+export const fetchSocialLinks = async () => {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping social links fetch");
+    return null as SocialLinksResponse["page"];
+  }
+
+  try {
+    const client = createApolloServerClient();
+    const timeoutPromise = new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("Social links fetch timeout")), 5000)
+    );
+
+    const queryPromise = client.query<{ page: SocialLinksResponse["page"] }>({
+      query: GET_SOCIAL_LINKS,
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    });
+
+    const result = await Promise.race([queryPromise, timeoutPromise]);
+    return result?.data?.page ?? null;
+  } catch (err) {
+    console.warn(
+      "Failed to fetch social links:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+    return null;
+  }
+};