@sitecore-content-sdk/core 0.1.0-beta.1

package/types/site/graphql-sitemap-service.d.ts

@@ -0,0 +1,55 @@
+import { GraphQLClient } from '../graphql';
+import { GraphQLRequestClientFactory } from '../graphql-request-client';
+export type GraphQLSitemapXmlServiceConfig = {
+    /**
+     * The JSS application name
+     */
+    siteName: string;
+    /**
+     * A GraphQL Request Client Factory is a function that accepts configuration and returns an instance of a GraphQLRequestClient.
+     * This factory function is used to create and configure GraphQL clients for making GraphQL API requests.
+     */
+    clientFactory: GraphQLRequestClientFactory;
+};
+/**
+ * The schema of data returned in response to sitemaps request
+ */
+export type SitemapQueryResult = {
+    site: {
+        siteInfo: {
+            sitemap: string[];
+        };
+    };
+};
+/**
+ * Service that fetch the sitemaps data using Sitecore's GraphQL API.
+ */
+export declare class GraphQLSitemapXmlService {
+    options: GraphQLSitemapXmlServiceConfig;
+    private graphQLClient;
+    /**
+     * Creates an instance of graphQL sitemaps service with the provided options
+     * @param {GraphQLSitemapXmlServiceConfig} options instance
+     */
+    constructor(options: GraphQLSitemapXmlServiceConfig);
+    protected get query(): string;
+    /**
+     * Fetch list of sitemaps for the site
+     * @returns {string[]} list of sitemap paths
+     * @throws {Error} if the siteName is empty.
+     */
+    fetchSitemaps(): Promise<string[]>;
+    /**
+     * Get sitemap file path for sitemap id
+     * @param {string} id the sitemap id (can be empty for default 'sitemap.xml' file)
+     * @returns {string | undefined} the sitemap file path or undefined if one doesn't exist
+     */
+    getSitemap(id: string): Promise<string | undefined>;
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    protected getGraphQLClient(): GraphQLClient;
+}

package/types/site/index.d.ts

@@ -0,0 +1,7 @@
+export { RobotsQueryResult, GraphQLRobotsService, GraphQLRobotsServiceConfig, } from './graphql-robots-service';
+export { RedirectInfo, RedirectsQueryResult, REDIRECT_TYPE_301, REDIRECT_TYPE_302, REDIRECT_TYPE_SERVER_TRANSFER, GraphQLRedirectsService, GraphQLRedirectsServiceConfig, } from './graphql-redirects-service';
+export { SitemapQueryResult, GraphQLSitemapXmlService, GraphQLSitemapXmlServiceConfig, } from './graphql-sitemap-service';
+export { ErrorPages, GraphQLErrorPagesService, GraphQLErrorPagesServiceConfig, } from './graphql-error-pages-service';
+export { SiteInfo, GraphQLSiteInfoService, GraphQLSiteInfoServiceConfig, } from './graphql-siteinfo-service';
+export { getSiteRewrite, getSiteRewriteData, normalizeSiteRewrite, SiteRewriteData } from './utils';
+export { SiteResolver } from './site-resolver';

package/types/site/site-resolver.d.ts

@@ -0,0 +1,27 @@
+import { SiteInfo } from './graphql-siteinfo-service';
+/**
+ * Resolves site based on the provided host or site name
+ */
+export declare class SiteResolver {
+    readonly sites: SiteInfo[];
+    /**
+     * @param {SiteInfo[]} sites Array of sites to be used in resolution
+     */
+    constructor(sites: SiteInfo[]);
+    /**
+     * Resolve site by host name
+     * @param {string} hostName the host name
+     * @returns {SiteInfo} the resolved site
+     * @throws {Error} if a matching site is not found
+     */
+    getByHost: (hostName: string) => SiteInfo;
+    /**
+     * Resolve site by site name
+     * @param {string} siteName the site name
+     * @returns {SiteInfo} the resolved site
+     * @throws {Error} if a matching site is not found
+     */
+    getByName: (siteName: string) => SiteInfo;
+    protected getHostMap: () => Map<string, SiteInfo>;
+    protected matchesPattern(hostname: string, pattern: string): boolean;
+}

package/types/site/utils.d.ts

@@ -0,0 +1,24 @@
+export declare const SITE_PREFIX = "_site_";
+export type SiteRewriteData = {
+    siteName: string;
+};
+/**
+ * Get a site rewrite path for given pathname
+ * @param {string} pathname the pathname
+ * @param {SiteRewriteData} data the site data to include in the rewrite
+ * @returns {string} the rewrite path
+ */
+export declare function getSiteRewrite(pathname: string, data: SiteRewriteData): string;
+/**
+ * Get site data from the rewrite path
+ * @param {string} pathname the pathname
+ * @param {string} defaultSiteName the default site name
+ * @returns {SiteRewriteData} the site data from the rewrite
+ */
+export declare function getSiteRewriteData(pathname: string, defaultSiteName: string): SiteRewriteData;
+/**
+ * Normalize a site rewrite path (remove site data)
+ * @param {string} pathname the pathname
+ * @returns {string} the pathname with site data removed
+ */
+export declare function normalizeSiteRewrite(pathname: string): string;

package/types/utils/env.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Method to parse JSON-formatted environment variables
+ * @param {string} envValue - can be undefined when providing values via process.env
+ * @param {T} defaultValue - default value
+ * @returns {T | string} parsed value
+ */
+export declare const tryParseEnvValue: <T>(envValue: string | undefined, defaultValue: T) => T;

package/types/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { default as isServer } from './is-server';
+export { resolveUrl, isAbsoluteUrl, isTimeoutError, enforceCors, EnhancedOmit, getAllowedOriginsFromEnv, isRegexOrUrl, areURLSearchParamsEqual, escapeNonSpecialQuestionMarks, mergeURLSearchParams, } from './utils';
+export { tryParseEnvValue } from './env';

package/types/utils/is-server.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines whether the current execution context is server-side
+ * @returns true if executing server-side
+ */
+declare function isServer(): boolean;
+export default isServer;

package/types/utils/timeout-promise.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A helper to assign timeouts to fetch or other promises
+ * Useful in nextjs middleware until fetch.signal is fully supported by Vercel edge functions
+ */
+export default class TimeoutPromise {
+    private timeout;
+    timeoutId: NodeJS.Timeout | undefined;
+    constructor(timeout: number);
+    /**
+     * Creates a timeout promise
+     */
+    get start(): Promise<unknown>;
+    /**
+     * Clears the timeout from timeout promise
+     */
+    clear(): void;
+}

package/types/utils/utils.d.ts

@@ -0,0 +1,71 @@
+import { IncomingMessage, OutgoingMessage } from 'http';
+import { ParsedUrlQueryInput } from 'querystring';
+/**
+ * Omit properties from T that are in K. This is a simplified version of TypeScript's built-in `Omit` utility type.
+ * Since default `Omit` doesn't support indexing types, we had to introduce this custom implementation.
+ */
+export type EnhancedOmit<T, K extends PropertyKey> = {
+    [P in keyof T as Exclude<P, K>]: T[P];
+};
+/**
+ * Resolves a base URL that may contain query string parameters and an additional set of query
+ * string parameters into a unified string representation.
+ * @param {string} urlBase the base URL that may contain query string parameters
+ * @param {ParsedUrlQueryInput} params query string parameters
+ * @returns a URL string
+ * @throws {RangeError} if the provided url is an empty string
+ */
+export declare function resolveUrl(urlBase: string, params?: ParsedUrlQueryInput): string;
+export declare const isAbsoluteUrl: (url: string) => boolean;
+/**
+ * Indicates whether the error is a timeout error
+ * @param {unknown} error error
+ * @returns {boolean} is timeout error
+ */
+export declare const isTimeoutError: (error: unknown) => boolean;
+/**
+ * Gets allowed origins from JSS_ALLOWED_ORIGINS env variable
+ * @returns {string[]} list of allowed origins from JSS_ALLOWED_ORIGINS env variable
+ */
+export declare const getAllowedOriginsFromEnv: () => string[];
+/**
+ * Tests origin from incoming request against allowed origins list that can be
+ * set in JSS's JSS_ALLOWED_ORIGINS env variable, passed via allowedOrigins param and/or
+ * be already set in Access-Control-Allow-Origin by other logic.
+ * Applies Access-Control-Allow-Origin and Access-Control-Allow-Methods on match
+ * Also applies Access-Control-Allow-Headers for preflight requests
+ * @param {IncomingMessage} req incoming request
+ * @param {OutgoingMessage} res response to set CORS headers for
+ * @param {string[]} [allowedOrigins] additional list of origins to test against
+ * @returns true if incoming origin matches the allowed lists, false when it does not
+ */
+export declare const enforceCors: (req: IncomingMessage, res: OutgoingMessage, allowedOrigins?: string[]) => boolean;
+/**
+ * Determines whether the given input is a regular expression or resembles a URL.
+ * @param {string} input - The input string to evaluate.
+ * @returns {'regex' | 'url'} - Returns 'url' if the input looks like a URL, otherwise 'regex'.
+ */
+export declare const isRegexOrUrl: (input: string) => "regex" | "url";
+/**
+ * Compares two URLSearchParams objects to determine if they are equal.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {boolean} - Returns true if the parameters are equal, otherwise false.
+ */
+export declare const areURLSearchParamsEqual: (params1: URLSearchParams, params2: URLSearchParams) => boolean;
+/**
+ * Escapes non-special "?" characters in a string or regex.
+ * - For regular strings, it escapes all unescaped "?" characters by adding a backslash (`\`).
+ * - For regex patterns (strings enclosed in `/.../`), it analyzes each "?" to determine if it has special meaning
+ *   (e.g., `?` in `(abc)?`, `.*?`, `(?!...)`) or is just a literal character. Only literal "?" characters are escaped.
+ * @param {string} input - The input string or regex pattern.
+ * @returns {string} - The modified string or regex with non-special "?" characters escaped.
+ */
+export declare const escapeNonSpecialQuestionMarks: (input: string) => string;
+/**
+ * Merges two URLSearchParams objects. If both objects contain the same key, the value from the second object overrides the first.
+ * @param {URLSearchParams} params1 - The first set of URL search parameters.
+ * @param {URLSearchParams} params2 - The second set of URL search parameters.
+ * @returns {string} - A string representation of the merged URL search parameters.
+ */
+export declare const mergeURLSearchParams: (params1: URLSearchParams, params2: URLSearchParams) => string;

package/utils.d.ts

@@ -0,0 +1 @@
+export * from './types/utils/index';

package/utils.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/utils/index');