@alphasquad/saleor-template-advance 0.1.0

package/src/graphql/queries/getBlogs.ts

@@ -0,0 +1,222 @@
+import { gql } from "@apollo/client"
+import createApolloServerClient from "../server-client"
+
+// Query to get the page type ID for articles-blogs
+export const GET_BLOG_PAGE_TYPE = gql`
+  query GetBlogPageType {
+    pageTypes(first: 100, filter: { slugs: "articles-blogs" }) {
+      edges {
+        node {
+          id
+          name
+          slug
+        }
+      }
+    }
+  }
+`
+
+// Query to get all blog pages by page type ID
+export const GET_BLOG_PAGES = gql`
+  query GetBlogPages($pageTypeId: [ID!], $first: Int = 100) {
+    pages(first: $first, filter: { pageTypes: $pageTypeId }) {
+      edges {
+        node {
+          id
+          title
+          slug
+          content
+          created
+          metadata {
+            key
+            value
+          }
+          pageType {
+            id
+            name
+            slug
+          }
+        }
+      }
+    }
+  }
+`
+
+export type BlogPage = {
+  id: string
+  title?: string | null
+  slug?: string | null
+  content?: string | null
+  created?: string | null
+  metadata?: Array<{ key?: string | null; value?: string | null } | null> | null
+  pageType?: {
+    id: string
+    name?: string | null
+    slug?: string | null
+  } | null
+}
+
+export type BlogPageTypeResponse = {
+  pageTypes?: {
+    edges?: Array<{
+      node?: {
+        id: string
+        name?: string | null
+        slug?: string | null
+      } | null
+    } | null>
+  }
+}
+
+export type BlogPagesResponse = {
+  pages?: {
+    edges?: Array<{ node?: BlogPage | null } | null>
+  }
+}
+
+// Helper function to extract first paragraph or generate excerpt from content
+function getExcerpt(content?: string | null): string {
+  if (!content) return ""
+
+  try {
+    const parsed = JSON.parse(content)
+    const blocks = Array.isArray(parsed?.blocks) ? parsed.blocks : []
+
+    // Find the first paragraph block
+    const firstParagraph = blocks.find((block: { type?: string; data?: { text?: string } }) => block?.type === "paragraph")
+    if (firstParagraph?.data?.text) {
+      // Strip HTML tags and limit length
+      const text = firstParagraph.data.text.replace(/<[^>]*>/g, "").trim()
+      return text.length > 150 ? text.substring(0, 150) + "..." : text
+    }
+  } catch {
+    // Ignore parsing errors
+  }
+
+  return ""
+}
+
+// Fetch all blog pages
+export async function fetchBlogPages(): Promise<Array<{
+  id: string
+  title: string
+  slug: string
+  excerpt: string
+  date: string
+}>> {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping blog fetch")
+    return []
+  }
+
+  try {
+    const client = createApolloServerClient()
+
+    // First, get the page type ID for articles-blogs
+    const pageTypeResponse = await client.query<BlogPageTypeResponse>({
+      query: GET_BLOG_PAGE_TYPE,
+      fetchPolicy: "cache-first",
+      errorPolicy: "all",
+      context: {
+        fetchOptions: {
+          next: { revalidate: 600 }, // Cache for 10 minutes
+        },
+      },
+    })
+
+    const pageTypeId = pageTypeResponse.data?.pageTypes?.edges?.[0]?.node?.id
+
+    if (!pageTypeId) {
+      console.warn("Blog page type 'articles-blogs' not found")
+      return []
+    }
+
+    // Then fetch all pages with this page type
+    const pagesResponse = await client.query<BlogPagesResponse>({
+      query: GET_BLOG_PAGES,
+      variables: { pageTypeId: [pageTypeId], first: 100 },
+      fetchPolicy: "cache-first",
+      errorPolicy: "all",
+      context: {
+        fetchOptions: {
+          next: { revalidate: 600 }, // Cache for 10 minutes
+        },
+      },
+    })
+
+    const pages = pagesResponse.data?.pages?.edges || []
+
+    return pages
+      .map((edge) => {
+        const node = edge?.node
+        if (!node || !node.slug || !node.title) return null
+
+        return {
+          id: node.id,
+          title: node.title,
+          slug: node.slug,
+          excerpt: getExcerpt(node.content),
+          date: node.created ? new Date(node.created).toLocaleDateString("en-US", {
+            year: "numeric",
+            month: "long",
+            day: "numeric"
+          }) : "",
+        }
+      })
+      .filter((blog): blog is NonNullable<typeof blog> => blog !== null)
+  } catch (err) {
+    console.warn(
+      "Failed to fetch blog pages:",
+      err instanceof Error ? err.message : "Unknown error"
+    )
+    return []
+  }
+}
+
+// Fetch a single blog page by slug
+export async function fetchBlogBySlug(slug: string): Promise<BlogPage | null> {
+  if (!process.env.NEXT_PUBLIC_API_URL) {
+    console.warn("API URL not configured, skipping blog fetch")
+    return null
+  }
+
+  try {
+    const client = createApolloServerClient()
+
+    const BLOG_BY_SLUG = gql`
+      query GetBlogBySlug($slug: String!) {
+        page(slug: $slug) {
+          id
+          title
+          slug
+          content
+          created
+          metadata {
+            key
+            value
+          }
+          pageType {
+            id
+            name
+            slug
+          }
+        }
+      }
+    `
+
+    const response = await client.query({
+      query: BLOG_BY_SLUG,
+      variables: { slug },
+      fetchPolicy: "network-only",
+      errorPolicy: "ignore",
+    })
+
+    return response?.data?.page ?? null
+  } catch (err) {
+    console.warn(
+      "Failed to fetch blog by slug:",
+      err instanceof Error ? err.message : "Unknown error"
+    )
+    return null
+  }
+}

package/src/graphql/queries/getBrands.ts

@@ -0,0 +1,17 @@
+import { gql } from "@apollo/client"
+
+export const GET_BRANDS = gql`
+  query GetBrands($first: Int!, $key: String!, $value: String!) {
+    productTypes(
+      first: $first
+      filter: { metadata: { key: $key, value: $value } }
+    ) {
+      edges {
+        node {
+          name
+          metafields
+        }
+      }
+    }
+  }
+`

package/src/graphql/queries/getBundles.ts

@@ -0,0 +1,43 @@
+import { gql } from "@apollo/client";
+
+export const GET_BUNDLES = gql`
+  query GetBundles($channel: String!, $first: Int = 10) {
+    collections(
+      first: 10
+      channel: $channel
+      filter: { metadata: [{ key: "bundle", value: "true" }] }
+    ) {
+      edges {
+        node {
+          id
+          name
+          slug
+          metadata {
+            key
+            value
+          }
+          products(first: $first) {
+            edges {
+              node {
+                id
+                name
+                slug
+                rating
+                pricing {
+                  onSale
+                  priceRange {
+                    start { gross { amount currency } }
+                    stop  { gross { amount currency } }
+                  }
+                  discount { gross { amount currency } }
+                }
+                media { url }
+                category { id name }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;

package/src/graphql/queries/getCategories.ts

@@ -0,0 +1,20 @@
+import { gql } from "@apollo/client";
+
+export const GET_CATEGORIES = gql`
+  query GetCategories($first: Int!) {
+    categories(first: $first) {
+      edges {
+        node {
+          id
+          name
+          description
+          slug
+          backgroundImage {
+            url
+          }
+        }
+      }
+      totalCount
+    }
+  }
+`;

package/src/graphql/queries/getChannels.ts

@@ -0,0 +1,77 @@
+import { gql } from "@apollo/client";
+
+export const GET_CHANNELS = gql`
+  query GetChannels {
+    channels {
+      id
+      name
+      slug
+      isActive
+      warehouses {
+        id
+        name
+        slug
+        email
+        isPrivate
+        address {
+          streetAddress1
+          streetAddress2
+          city
+        phone
+          postalCode
+          countryArea
+          country {
+            code
+            country
+          }
+        }
+        privateMetadata {
+          key
+          value
+        }
+      }
+    }
+  }
+`;
+
+
+export interface Address {
+  streetAddress1?: string;
+  streetAddress2?: string;
+  city?: string;
+  phone?: string;
+  postalCode?: string;
+  countryArea?: string;
+  country?: {
+    code: string;
+    country: string;
+  };
+}
+
+export interface PrivateMetadata {
+  key: string;
+  value: string;
+}
+
+export interface Warehouse {
+  id: string;
+  name: string;
+  slug: string;
+  email?: string;
+  isPrivate: boolean;
+  address?: Address;
+  privateMetadata?: PrivateMetadata[];
+}
+
+
+export interface Channel {
+  id: string;
+  name: string;
+  slug: string;
+  isActive: boolean;
+  warehouses: Warehouse[];
+}
+
+export interface GetChannelsData {
+  channels: Channel[];
+}

package/src/graphql/queries/getCheckoutQuestions.ts

@@ -0,0 +1,115 @@
+import { gql } from "@apollo/client";
+
+export const GET_CHECKOUT_QUESTIONS = gql`
+  query GetCheckoutQuestions {
+    page(slug: "checkout-question") {
+      id
+      title
+      slug
+      content
+      seoTitle
+      seoDescription
+      isPublished
+      metadata {
+        key
+        value
+      }
+    }
+  }
+`;
+
+export interface CheckoutQuestionMetadata {
+  key: string;
+  value: string;
+}
+
+export interface CheckoutQuestionsData {
+  page: {
+    id: string;
+    title: string;
+    slug: string;
+    content: string | null;
+    seoTitle: string;
+    seoDescription: string;
+    isPublished: boolean;
+    metadata: CheckoutQuestionMetadata[];
+  } | null;
+}
+
+export interface ParsedQuestion {
+  id: string;
+  required: boolean;
+  question: string;
+  options?: string[];
+  type: 'text' | 'select' | 'radio' | 'checkbox';
+}
+
+export interface CheckoutQuestionsConfig {
+  isPublished: boolean;
+  guestOnly: boolean;
+  orderValueThreshold: number | null;
+  showReCAPTCHA: boolean;
+  questions: ParsedQuestion[];
+}
+
+export function parseCheckoutQuestions(data: CheckoutQuestionsData): CheckoutQuestionsConfig | null {
+  if (!data?.page) {
+    return null;
+  }
+  
+  if (!data.page.isPublished) {
+    return null;
+  }
+
+  const metadata = data.page.metadata;
+  const questions: ParsedQuestion[] = [];
+  
+  let guestOnly = false;
+  let orderValueThreshold: number | null = null;
+  let showReCAPTCHA = false;
+
+  metadata.forEach(({ key, value }) => {
+    if (key === 'guest_only') {
+      guestOnly = value === 'true';
+    } else if (key === 'order_value') {
+      const parsed = parseFloat(value);
+      orderValueThreshold = isNaN(parsed) ? null : parsed;
+    } else if (key === 'reCAPTCHA') {
+      showReCAPTCHA = value === 'true';
+    } else if (key.startsWith('question-')) {
+      const questionId = key;
+      const parts = value.split(':');
+      
+      if (parts.length >= 2) {
+        const requiredStr = parts[0].trim();
+        const required = requiredStr === 'r';
+        const question = parts[1].trim();
+        
+        // Handle options - check if parts[2] exists and is not empty
+        let options: string[] | undefined = undefined;
+        if (parts.length > 2 && parts[2].trim()) {
+          options = parts[2].split(',').map(opt => opt.trim()).filter(opt => opt.length > 0);
+        }
+        
+        // Only add question if it has a question text
+        if (question) {
+          questions.push({
+            id: questionId,
+            required,
+            question,
+            options,
+            type: options && options.length > 0 ? (options.length <= 4 ? 'radio' : 'select') : 'text'
+          });
+        }
+      }
+    }
+  });
+
+  return {
+    isPublished: data.page.isPublished,
+    guestOnly,
+    orderValueThreshold,
+    showReCAPTCHA,
+    questions: questions.sort((a, b) => a.id.localeCompare(b.id))
+  };
+}

package/src/graphql/queries/getCheckoutTermsAndConditions.ts

@@ -0,0 +1,37 @@
+import { gql } from "@apollo/client"
+
+export const GET_CHECKOUT_TERMS_AND_CONDITIONS = gql`
+  query CheckoutTermsAndConditions($slug: String!) {
+    page(slug: $slug) {
+      id
+      title
+      slug
+      content
+      seoTitle
+      seoDescription
+      isPublished
+      metadata {
+        key
+        value
+      }
+    }
+  }
+`
+
+export type CheckoutTermsAndConditionsPage = {
+  id: string
+  title: string | null
+  slug: string | null
+  content: string | null
+  seoTitle: string | null
+  seoDescription: string | null
+  isPublished: boolean
+  metadata: Array<{
+    key: string
+    value: string
+  }> | null
+}
+
+export type CheckoutTermsAndConditionsResponse = { 
+  page: CheckoutTermsAndConditionsPage | null 
+}

package/src/graphql/queries/getContactPage.ts

@@ -0,0 +1,117 @@
+import { gql } from "@apollo/client";
+import createApolloServerClient from "../server-client";
+
+export const GET_CONTACT_PAGE = gql`
+  query Contact($first: Int = 1) {
+    pages(first: $first, filter: { slugs: "contact" }) {
+      edges {
+        node {
+          id
+          title
+          content
+          metadata {
+            key
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+
+export type ContactMetadata = {
+  key: string;
+  value: string;
+};
+
+export type ContactPageNode = {
+  id: string;
+  title: string;
+  content: string | null;
+  metadata: ContactMetadata[];
+};
+
+export type ContactPageEdge = {
+  node: ContactPageNode;
+};
+
+export type ContactPageResponse = {
+  pages: {
+    edges: ContactPageEdge[];
+  };
+};
+
+export type ContactPageData = {
+  id: string;
+  title: string;
+  content: string | null;
+  contactFormEnabled: 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: ContactPageNode): ContactPageData {
+  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",
+    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<ContactPageData | 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<ContactPageResponse>({
+      query: GET_CONTACT_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 parseContactPageMetadata(edges[0].node);
+    }
+
+    return null;
+  } catch (err) {
+    console.warn(
+      "Failed to fetch contact page:",
+      err instanceof Error ? err.message : "Unknown error"
+    );
+    return null;
+  }
+}