@exdst-sitecore-content-sdk/astro 0.0.1

package/src/middleware/multisite-middleware.ts

@@ -0,0 +1,147 @@
+/* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
+import { getSiteRewrite, SITE_KEY } from '@sitecore-content-sdk/core/site';
+import { debug } from '@sitecore-content-sdk/core';
+import { MiddlewareBase, MiddlewareBaseConfig } from './middleware';
+import { SitecoreConfig } from '../config';
+import { PREVIEW_KEY } from '@sitecore-content-sdk/core/editing';
+import { APIContext, MiddlewareHandler, MiddlewareNext } from 'astro';
+import * as cookie from 'cookie';
+
+export type CookieAttributes = {
+  /**
+   * the Secure attribute of the site cookie
+   */
+  secure: boolean;
+  /**
+   * the HttpOnly attribute of the site cookie
+   */
+  httpOnly: boolean;
+  /**
+   * the SameSite attribute of the site cookie
+   */
+  sameSite?: true | false | 'lax' | 'strict' | 'none' | undefined;
+};
+
+export type MultisiteMiddlewareConfig = MiddlewareBaseConfig & SitecoreConfig['multisite'];
+
+/**
+ * Middleware / handler for multisite support
+ */
+export class MultisiteMiddleware extends MiddlewareBase {
+  /**
+   * @param {MultisiteMiddlewareConfig} [config] Multisite middleware config
+   */
+  constructor(protected config: MultisiteMiddlewareConfig) {
+    super(config);
+  }
+
+  handle: MiddlewareHandler = async (context: APIContext, next: MiddlewareNext) => {
+    if (this.disabledInChain(context)) {
+      debug.multisite(
+        'skipped (multisite middleware is disabled by one of the previous middlewares)'
+      );
+      return next();
+    }
+
+    try {
+      const pathname = context.url.pathname;
+      const language = this.getLanguage(context);
+      const hostname = this.getHostHeader(context) || this.defaultHostname;
+      const startTimestamp = Date.now();
+
+      debug.multisite('multisite middleware start: %o', {
+        pathname,
+        language,
+        hostname,
+      });
+
+      if (this.isPreview(context)) {
+        debug.multisite('skipped (preview)');
+
+        return next();
+      }
+
+      // Site name preservation is required for Sitecore Preview mode to support navigation between pages
+      const isSitecorePreview = context.cookies.get(PREVIEW_KEY)?.value;
+
+      if (!isSitecorePreview) {
+        if (!this.config.enabled) {
+          debug.multisite('skipped (multisite middleware is disabled globally)');
+          return next();
+        }
+
+        if (this.disabled(context)) {
+          debug.multisite('skipped (multisite middleware is disabled)');
+
+          return next();
+        }
+      }
+
+      let siteName: string;
+
+      if (isSitecorePreview) {
+        // This cookie is required to be set in the Sitecore Preview mode to support navigation
+        // and preserve the site name
+        siteName = context.cookies.get(SITE_KEY)?.value!;
+      } else {
+        // Site name can be forced by query string parameter or cookie
+        siteName =
+          context.url.searchParams.get(SITE_KEY) ||
+          context.url.searchParams.get('site') ||
+          (this.config.useCookieResolution &&
+            this.config.useCookieResolution(context.request) &&
+            context.cookies.get(SITE_KEY)?.value) ||
+          this.siteResolver.getByHost(hostname).name;
+      }
+
+      // Rewrite to site specific path
+      const rewritePath = this.getSiteRewrite(pathname, siteName);
+
+      // Set rewrite header
+      const response = await this.rewrite(rewritePath, context, next);
+
+      // default site cookie attributes
+      const defaultCookieAttributes = {
+        secure: true,
+        httpOnly: true,
+        sameSite: 'none',
+      } as CookieAttributes;
+
+      // Share site name with the following executed middlewares
+      response.headers.append(
+        'Set-Cookie',
+        cookie.serialize(SITE_KEY, siteName, defaultCookieAttributes)
+      );
+
+      debug.multisite('multisite middleware end in %dms: %o', Date.now() - startTimestamp, {
+        rewritePath,
+        siteName,
+        headers: this.extractDebugHeaders(response.headers),
+        cookies: response.headers.get('Set-Cookie'),
+      });
+
+      return response;
+    } catch (error) {
+      console.log('Multisite middleware failed:');
+      console.log(error);
+      return next();
+    }
+  };
+
+  protected disabled(context: APIContext): boolean | undefined {
+    // ignore files
+    return context.url.pathname.includes('.') || super.disabled(context);
+  }
+
+  /**
+   * Generates a site-specific rewrite path based on the provided pathname and site name.
+   * @param {string} pathname - The pathname to be rewritten.
+   * @param {string} siteName - The name of the site.
+   * @returns The rewritten path as a string.
+   */
+  protected getSiteRewrite(pathname: string, siteName: string): string {
+    return getSiteRewrite(pathname, {
+      siteName,
+    });
+  }
+}

package/src/middleware/robots-middleware.test.ts

@@ -0,0 +1,113 @@
+import * as chai from 'chai';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import { RobotsMiddleware } from './robots-middleware';
+import { SitecoreClient } from '@sitecore-content-sdk/core/client';
+import { SiteInfo } from '@sitecore-content-sdk/core/site';
+import { mockRequest } from '../test-data/helpers';
+
+chai.use(sinonChai);
+
+describe('RobotsMiddleware', () => {
+  const sandbox = sinon.createSandbox();
+  let sitecoreClientStub: sinon.SinonStubbedInstance<SitecoreClient>;
+  let middleware: RobotsMiddleware;
+  let req: Partial<Request>;
+  let siteResolverStub = {
+    getByHost: sandbox.stub(),
+    getByName: sandbox.stub(),
+  };
+
+  const mockSiteInfo: SiteInfo = {
+    name: 'test-site',
+    hostName: 'example.com',
+    language: 'en',
+  };
+
+  const sites = [mockSiteInfo, { name: 'test-site-two', hostName: 'localhost', language: 'da' }];
+
+  beforeEach(() => {
+    sitecoreClientStub = sandbox.createStubInstance(SitecoreClient);
+    siteResolverStub = {
+      getByHost: sandbox.stub(),
+      getByName: sandbox.stub(),
+    };
+
+    req = mockRequest({
+      headers: {
+        host: 'example.com',
+      },
+    });
+
+    middleware = new RobotsMiddleware(sitecoreClientStub as unknown as SitecoreClient, sites);
+    (middleware as any).siteResolver = siteResolverStub;
+    siteResolverStub.getByHost.callsFake((hostName) =>
+      sites.find((site) => site.hostName === hostName)
+    );
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should set the content type header to text/plain', async () => {
+    sitecoreClientStub.getRobots.resolves('User-agent: *\nDisallow: /');
+
+    const res = await middleware.getHandler()(req as Request);
+
+    expect(res.headers.get('Content-Type')).to.equal('text/plain');
+  });
+
+  it('should call getRobots with the correct siteName', async () => {
+    sitecoreClientStub.getRobots.resolves('User-agent: *\nDisallow: /');
+
+    await middleware.getHandler()(req as Request);
+
+    expect(sitecoreClientStub.getRobots).to.have.been.calledWith('test-site');
+  });
+
+  it('should return 200 with robots content', async () => {
+    sitecoreClientStub.getRobots.resolves('User-agent: *\nDisallow: /');
+
+    const res = await middleware.getHandler()(req as Request);
+
+    const body = await res.text();
+    expect(res.status).to.equal(200);
+    expect(body).to.deep.equal('User-agent: *\nDisallow: /');
+  });
+
+  it('should return 404 if getRobots returns null', async () => {
+    sitecoreClientStub.getRobots.resolves(undefined);
+
+    const res = await middleware.getHandler()(req as Request);
+
+    const body = await res.text();
+    expect(res.status).to.equal(404);
+    expect(body).to.deep.equal('User-agent: *\nDisallow: /');
+  });
+
+  it('should return 500 if getRobots throws an error', async () => {
+    sitecoreClientStub.getRobots.rejects(new Error('Unexpected failure'));
+
+    const res = await middleware.getHandler()(req as Request);
+
+    const body = await res.text();
+    expect(res.status).to.equal(500);
+    expect(body).to.deep.equal('Internal Server Error');
+  });
+
+  it('should use "localhost" as fallback when host header is missing', async () => {
+    req = new Request('https://test.com'); // no host header
+
+    sitecoreClientStub.getRobots.resolves('User-agent: *\nDisallow: /');
+
+    const res = await middleware.getHandler()(req as Request);
+
+    expect(sitecoreClientStub.getRobots).to.have.been.calledWith('test-site-two');
+
+    const body = await res.text();
+    expect(res.status).to.equal(200);
+    expect(body).to.deep.equal('User-agent: *\nDisallow: /');
+  });
+});

package/src/middleware/robots-middleware.ts

@@ -0,0 +1,47 @@
+import { SitecoreClient } from '@sitecore-content-sdk/core/client';
+import { SiteInfo, SiteResolver } from '../site';
+
+/**
+ * Middleware for handling robots.txt requests.
+ */
+export class RobotsMiddleware {
+  private client: SitecoreClient;
+  private siteResolver: SiteResolver;
+
+  constructor(client: SitecoreClient, sites: SiteInfo[]) {
+    this.client = client;
+    this.siteResolver = new SiteResolver(sites);
+  }
+
+  getHandler() {
+    return this.handler.bind(this);
+  }
+
+  private async handler(_req: Request): Promise<Response> {
+    const _res = new Response();
+    _res.headers.append('content-type', 'text/plain');
+
+    const hostName = _req.headers.get('host')?.split(':')[0] || 'localhost';
+    const site = this.siteResolver.getByHost(hostName);
+
+    try {
+      const robotsContent = await this.client.getRobots(site.name);
+      if (!robotsContent) {
+        return new Response('User-agent: *\nDisallow: /', {
+          status: 404,
+          headers: _res.headers,
+        });
+      }
+
+      return new Response(robotsContent, {
+        status: 200,
+        headers: _res.headers,
+      });
+    } catch {
+      return new Response('Internal Server Error', {
+        status: 500,
+        headers: _res.headers,
+      });
+    }
+  }
+}

package/src/middleware/sitemap-middleware.test.ts

@@ -0,0 +1,152 @@
+/* eslint-disable no-unused-expressions, @typescript-eslint/no-unused-expressions */
+import * as chai from 'chai';
+import { expect } from 'chai';
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import { SitemapMiddleware } from './sitemap-middleware';
+import { SitecoreClient } from '@sitecore-content-sdk/core/client';
+import { mockRequest } from '../test-data/helpers';
+
+chai.use(sinonChai);
+
+describe('SitemapMiddleware', () => {
+  const sandbox = sinon.createSandbox();
+  let sitecoreClientStub: sinon.SinonStubbedInstance<SitecoreClient>;
+  let middleware: SitemapMiddleware;
+  let req: Partial<Request>;
+  let siteResolverStub = {
+    getByHost: sandbox.stub(),
+    getByName: sandbox.stub(),
+  };
+
+  const sites = [
+    { name: 'test-site', hostName: 'example.com', language: 'en' },
+    { name: 'test-site-two', hostName: '*', language: 'da' },
+  ];
+
+  beforeEach(() => {
+    sitecoreClientStub = sandbox.createStubInstance(SitecoreClient);
+
+    req = mockRequest({
+      headers: {
+        host: 'example.com',
+        'x-forwarded-proto': 'https',
+      },
+    });
+
+    siteResolverStub = {
+      getByHost: sandbox.stub(),
+      getByName: sandbox.stub(),
+    };
+
+    middleware = new SitemapMiddleware(sitecoreClientStub as unknown as SitecoreClient, sites);
+    (middleware as any).siteResolver = siteResolverStub;
+    siteResolverStub.getByHost.callsFake((hostName) =>
+      sites.find((site) => site.hostName === hostName)
+    );
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('getHandler', () => {
+    it('should return a handler function', () => {
+      const handler = middleware.getHandler();
+      expect(handler).to.be.a('function');
+    });
+  });
+
+  describe('handler', () => {
+    it('should process sitemap request without id parameter', async () => {
+      const siteName = sites[0].name;
+      const xmlContent = '<sitemapindex>...</sitemapindex>';
+
+      sitecoreClientStub.getSiteMap.resolves(xmlContent);
+
+      const res = await middleware.getHandler()(req as Request);
+
+      expect(sitecoreClientStub.getSiteMap.calledOnce).to.be.true;
+      expect(sitecoreClientStub.getSiteMap.firstCall.args[0]).to.deep.include({
+        reqHost: 'example.com',
+        reqProtocol: 'https',
+        id: '',
+        siteName: siteName,
+      });
+
+      expect(res.headers.get('Content-Type')).to.equal('text/xml;charset=utf-8');
+
+      const body = await res.text();
+      expect(body).to.deep.equal(xmlContent);
+    });
+
+    it('should handle sitemap request with specific id parameter', async () => {
+      const sitemapId = '1';
+      req = mockRequest({
+        url: `https://test.com/sitemap-${sitemapId}.xml`,
+        headers: {
+          host: 'example.com',
+          'x-forwarded-proto': 'https',
+        },
+      });
+      const siteName = sites[0].name;
+      const xmlContent = '<urlset>...</urlset>';
+
+      sitecoreClientStub.getSiteMap.resolves(xmlContent);
+
+      const res = await middleware.getHandler()(req as Request);
+
+      expect(sitecoreClientStub.getSiteMap.firstCall.args[0]).to.deep.include({
+        reqHost: 'example.com',
+        reqProtocol: 'https',
+        id: sitemapId,
+        siteName: siteName,
+      });
+
+      const body = await res.text();
+      expect(body).to.deep.equal(xmlContent);
+    });
+
+    it('should default to https protocol when x-forwarded-proto header is missing', async () => {
+      req.headers?.delete('x-forwarded-proto');
+      const siteName = sites[0].name;
+      const xmlContent = '<sitemapindex>...</sitemapindex>';
+
+      sitecoreClientStub.getSiteMap.resolves(xmlContent);
+
+      await middleware.getHandler()(req as Request);
+
+      expect(sitecoreClientStub.getSiteMap.firstCall.args[0]).to.deep.include({
+        reqHost: 'example.com',
+        reqProtocol: 'https',
+        siteName: siteName,
+      });
+    });
+
+    it('should redirect to 404 when REDIRECT_404 error is thrown', async () => {
+      const error = new Error('REDIRECT_404');
+
+      sitecoreClientStub.getSiteMap.rejects(error);
+
+      const res = await middleware.getHandler()(req as Request);
+
+      expect(res.status).to.equal(302);
+      expect(res.body).to.equal(null);
+
+      expect(res.headers.has('Location')).to.be.true;
+      expect(res.headers.get('Location')).to.equal('/404');
+    });
+
+    it('should return 500 error when any other error occurs', async () => {
+      const error = new Error('Unexpected error');
+
+      sitecoreClientStub.getSiteMap.rejects(error);
+
+      const res = await middleware.getHandler()(req as Request);
+
+      const body = await res.text();
+      expect(res.status).to.equal(500);
+      expect(body).to.equal('Internal Server Error');
+    });
+  });
+});

package/src/middleware/sitemap-middleware.ts

@@ -0,0 +1,65 @@
+import {
+  SitecoreClient,
+  SitemapXmlOptions,
+} from '@sitecore-content-sdk/core/client';
+import { SiteInfo, SiteResolver } from '../site';
+
+/**
+ * Middleware for handling sitemap requests.
+ * Encapsulates all HTTP-related logic for sitemap generation and delivery.
+ */
+export class SitemapMiddleware {
+  private client: SitecoreClient;
+  private siteResolver: SiteResolver;
+
+  constructor(client: SitecoreClient, sites: SiteInfo[]) {
+    this.client = client;
+    this.siteResolver = new SiteResolver(sites);
+  }
+
+  getHandler() {
+    return this.handler.bind(this);
+  }
+
+  private async handler(_req: Request): Promise<Response> {
+    const url = new URL(_req.url.toLowerCase());
+
+    const segments = url.pathname.split('/');
+    const idMatch = segments[1].match(/(\d+)(?=\.xml$)/);
+    const id = idMatch ? idMatch[1] : '';
+
+    const reqHost = _req.headers.get('host') || '';
+    const reqProtocol = _req.headers.get('x-forwarded-proto') || 'https';
+    const site = this.siteResolver.getByHost(reqHost);
+
+    const options: SitemapXmlOptions = {
+      reqHost,
+      reqProtocol,
+      id,
+      siteName: site.name,
+    };
+
+    try {
+      const xmlContent = await this.client.getSiteMap(options);
+
+      return new Response(xmlContent, {
+        headers: {
+          'Content-Type': 'text/xml;charset=utf-8',
+        },
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message === 'REDIRECT_404') {
+        return new Response(null, {
+          status: 302,
+          headers: {
+            location: '/404',
+          },
+        });
+      } else {
+        return new Response('Internal Server Error', {
+          status: 500,
+        });
+      }
+    }
+  }
+}

package/src/services/component-props-service.ts

@@ -0,0 +1,182 @@
+// import chalk from 'chalk';
+import {
+  LayoutServiceData,
+  ComponentRendering,
+  PlaceholdersData,
+} from '@sitecore-content-sdk/core/layout';
+import {
+  AstroContentSdkComponent,
+  ComponentMap,
+  ComponentPropsCollection,
+} from '../sharedTypes/component-props';
+
+export type FetchComponentPropsArguments = {
+  layoutData: LayoutServiceData;
+  // context: NextContext;
+  components: ComponentMap<AstroContentSdkComponent>;
+};
+
+export type ComponentPropsRequest = {
+  // fetch: ComponentPropsFetchFunction;
+  layoutData: LayoutServiceData;
+  rendering: ComponentRendering;
+  // context: NextContext;
+};
+
+export class ComponentPropsService {
+  async fetchComponentProps(
+    params: FetchComponentPropsArguments
+  ): Promise<ComponentPropsCollection> {
+    const { layoutData, components } = params;
+    const requests = await this.collectRequests({
+      placeholders: layoutData.sitecore.route?.placeholders,
+      components,
+      layoutData,
+      // context,
+    });
+    return await this.execRequests(requests);
+  }
+
+  /**
+   * Go through layout service data, check all renderings using displayName, which should make some side effects.
+   * Write result in requests variable
+   * @param {object} params params
+   * @param {PlaceholdersData} [params.placeholders]
+   * @param {ComponentMap} params.components
+   * @param {LayoutServiceData} params.layoutData
+   * @param {ComponentPropsRequest[]} params.requests
+   * @returns {ComponentPropsRequest[]} array of requests
+   */
+  protected async collectRequests(params: {
+    placeholders?: PlaceholdersData;
+    components: ComponentMap<AstroContentSdkComponent>;
+    layoutData: LayoutServiceData;
+    // context: NextContext;
+    requests?: ComponentPropsRequest[];
+  }): Promise<ComponentPropsRequest[]> {
+    const { placeholders = {}, layoutData } = params;
+
+    // Will be called on first round
+    if (!params.requests) {
+      params.requests = [];
+    }
+
+    const renderings = this.flatRenderings(placeholders);
+
+    const actions = renderings.map(async (r) => {
+      // const fetchFunc = (await this.getModule(components, r.componentName))
+      //  ?.getComponentServerProps;
+
+      const fetchFunc = ""; // getModule
+
+      if (fetchFunc) {
+        params.requests &&
+          params.requests.push({
+            // fetch: fetchFunc,
+            rendering: r,
+            layoutData: layoutData,
+            // context,
+          });
+      }
+
+      // If placeholders exist in current rendering
+      if (r.placeholders) {
+        await this.collectRequests({
+          ...params,
+          placeholders: r.placeholders,
+        });
+      }
+    });
+
+    await Promise.all(actions);
+
+    return params.requests;
+  }
+
+  /**
+   * Execute request for component props
+   * @param {ComponentPropsRequest[]} requests requests
+   * @returns {Promise<ComponentPropsCollection>} requests result
+   */
+  protected async execRequests(
+    requests: ComponentPropsRequest[]
+  ): Promise<ComponentPropsCollection> {
+    const componentProps: ComponentPropsCollection = {};
+
+    const promises = requests.map((req) => {
+      const { uid } = req.rendering;
+
+      if (!uid) {
+        console.log(
+          `Component ${req.rendering.componentName} doesn't have uid, can't store data for this component`
+        );
+        return;
+      }
+
+
+      // return req
+      //   .fetch(req.rendering, req.layoutData /*, req.context*/)
+      //   .then((result) => {
+      //     // Set component specific data in componentProps store
+      //     componentProps[uid] = result;
+      //   })
+      //   .catch((error) => {
+      //     const errLog = `Error during preload data for component ${
+      //       req.rendering.componentName
+      //     } (${uid}): ${error.message || error}`;
+
+      //     console.error(chalk.red(errLog));
+
+      //     componentProps[uid] = {
+      //       error: error.message || errLog,
+      //       componentName: req.rendering.componentName,
+      //     };
+      //   });
+    });
+
+    await Promise.all(promises);
+
+    return componentProps;
+  }
+
+  /**
+   * Take renderings from all placeholders and returns a flat array of renderings.
+   * @example
+   * const placeholders = {
+   *    x1: [{ uid: 1 }, { uid: 2 }],
+   *    x2: [{ uid: 11 }, { uid: 22 }]
+   * }
+   *
+   * flatRenderings(placeholders);
+   *
+   * RESULT: [{ uid: 1 }, { uid: 2 }, { uid: 11 }, { uid: 22 }]
+   * @param {PlaceholdersData} placeholders placeholders
+   * @returns {ComponentRendering[]} renderings
+   */
+  protected flatRenderings(
+    placeholders: PlaceholdersData
+  ): ComponentRendering[] {
+    const allComponentRenderings: ComponentRendering[] = [];
+    const placeholdersArr = Object.values(placeholders);
+
+    placeholdersArr.forEach((pl) => {
+      const renderings = pl as ComponentRendering[];
+      allComponentRenderings.push(...renderings);
+    });
+
+    return allComponentRenderings;
+  }
+
+  // private async getModule(
+  //   components: ComponentMap<AstroContentSdkComponent>,
+  //   componentName: string
+  // ) {
+  //   const component = components.get(componentName);
+
+  //   if (!component) return null;
+
+  //   //const module = component.dynamicModule ? await component?.dynamicModule?.() : component;
+  //   const module = component;
+  //   return module as AstroContentSdkComponent;
+  // }
+}