@unchainedshop/cockpit-api 1.0.34 → 2.1.0

package/dist/methods/search.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Search API methods (Detektivo addon)
+ */
+import type { MethodContext } from "./content.ts";
+export interface SearchQueryOptions {
+    index: string;
+    q?: string;
+    /** Comma-separated list of fields to retrieve */
+    fields?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface CockpitSearchHit {
+    _id: string;
+    _score: number;
+    _source: Record<string, unknown>;
+    highlight?: Record<string, string[]>;
+}
+export interface CockpitSearchResult {
+    hits: CockpitSearchHit[];
+    total: number;
+    took: number;
+}
+export interface SearchMethods {
+    search<T = CockpitSearchResult>(options: SearchQueryOptions): Promise<T | null>;
+}
+export declare function createSearchMethods(ctx: MethodContext): SearchMethods;

package/dist/methods/search.js

@@ -0,0 +1,16 @@
+/**
+ * Search API methods (Detektivo addon)
+ */
+import { requireParam } from "../core/validation.js";
+export function createSearchMethods(ctx) {
+    return {
+        async search(options) {
+            const { index, q, fields, limit, offset } = options;
+            requireParam(index, "a search index");
+            const url = ctx.url.build(`/detektivo/search/${index}`, {
+                queryParams: { q, fields, limit, offset },
+            });
+            return ctx.http.fetch(url);
+        },
+    };
+}

package/dist/methods/system.d.ts

@@ -0,0 +1,15 @@
+/**
+ * System API methods
+ */
+import type { MethodContext } from "./content.ts";
+export interface CockpitHealthCheck {
+    status: "ok" | "error";
+    message?: string;
+    version?: string;
+    timestamp?: string;
+}
+export interface SystemMethods {
+    healthCheck<T = unknown>(): Promise<T | null>;
+    clearCache(pattern?: string): void;
+}
+export declare function createSystemMethods(ctx: MethodContext): SystemMethods;

package/dist/methods/system.js

@@ -0,0 +1,14 @@
+/**
+ * System API methods
+ */
+export function createSystemMethods(ctx) {
+    return {
+        async healthCheck() {
+            const url = ctx.url.build("/system/healthcheck");
+            return ctx.http.fetch(url);
+        },
+        clearCache(pattern) {
+            ctx.cache.clear(pattern);
+        },
+    };
+}

package/dist/schema/executor.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Remote executor for Cockpit GraphQL schema stitching
+ */
+import type { DocumentNode } from "graphql";
+import type { CockpitAPIOptions } from "../core/config.ts";
+/**
+ * Context passed to the remote executor
+ * Typically includes the request object for extracting tenant info
+ */
+export interface CockpitExecutorContext {
+    req?: {
+        headers?: Record<string, string | string[] | undefined>;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Options for creating the Cockpit GraphQL schema
+ */
+export interface MakeCockpitSchemaOptions {
+    /** Header name to extract tenant from (default: "x-cockpit-space") */
+    tenantHeader?: string;
+    /** Filter out mutations from the schema (default: true) */
+    filterMutations?: boolean;
+    /** Additional transforms to apply to the schema */
+    transforms?: unknown[];
+    /** Custom tenant extractor function */
+    extractTenant?: (context: CockpitExecutorContext | undefined) => string | undefined;
+    /** CockpitAPI options to pass through (endpoint, apiKey, useAdminAccess) */
+    cockpitOptions?: Pick<CockpitAPIOptions, "endpoint" | "apiKey" | "useAdminAccess">;
+    /** Maximum number of clients to keep in the pool (default: 100) */
+    maxClients?: number;
+}
+/**
+ * Executor request signature for GraphQL Tools
+ */
+export interface ExecutorRequest {
+    document: DocumentNode;
+    variables?: Record<string, unknown>;
+    context?: CockpitExecutorContext;
+}
+/**
+ * Remote executor function type
+ */
+export type RemoteExecutor = (request: ExecutorRequest) => Promise<unknown>;
+/**
+ * Creates a remote executor for Cockpit GraphQL
+ *
+ * The executor resolves the tenant from context and reuses
+ * CockpitAPI clients per tenant for efficiency.
+ *
+ * @example
+ * ```typescript
+ * import { createRemoteExecutor } from "@unchainedshop/cockpit-api/schema";
+ *
+ * const executor = createRemoteExecutor({
+ *   tenantHeader: "x-cockpit-space",
+ * });
+ *
+ * // Use with custom schema tooling
+ * const result = await executor({
+ *   document: someQuery,
+ *   variables: { id: "123" },
+ *   context: { req: request },
+ * });
+ * ```
+ */
+export declare function createRemoteExecutor(options?: MakeCockpitSchemaOptions): RemoteExecutor;

package/dist/schema/executor.js

@@ -0,0 +1,81 @@
+/**
+ * Remote executor for Cockpit GraphQL schema stitching
+ */
+import { LRUCache } from "lru-cache";
+import { CockpitAPI } from "../client.js";
+/** Default max clients to keep in pool */
+const DEFAULT_MAX_CLIENTS = 100;
+/**
+ * Default tenant extractor - reads from request header
+ */
+function defaultTenantExtractor(context, headerName) {
+    if (!context?.req?.headers)
+        return undefined;
+    const value = context.req.headers[headerName];
+    return Array.isArray(value) ? value[0] : value;
+}
+/**
+ * Creates a remote executor for Cockpit GraphQL
+ *
+ * The executor resolves the tenant from context and reuses
+ * CockpitAPI clients per tenant for efficiency.
+ *
+ * @example
+ * ```typescript
+ * import { createRemoteExecutor } from "@unchainedshop/cockpit-api/schema";
+ *
+ * const executor = createRemoteExecutor({
+ *   tenantHeader: "x-cockpit-space",
+ * });
+ *
+ * // Use with custom schema tooling
+ * const result = await executor({
+ *   document: someQuery,
+ *   variables: { id: "123" },
+ *   context: { req: request },
+ * });
+ * ```
+ */
+export function createRemoteExecutor(options = {}) {
+    const { tenantHeader = "x-cockpit-space", extractTenant, cockpitOptions = {}, maxClients = DEFAULT_MAX_CLIENTS, } = options;
+    // Client pool with LRU eviction to prevent unbounded memory growth
+    const clientPool = new LRUCache({
+        max: maxClients,
+    });
+    const pendingClients = new Map();
+    async function getOrCreateClient(tenant) {
+        const key = tenant ?? "__default__";
+        // Return cached client if available
+        const cached = clientPool.get(key);
+        if (cached)
+            return cached;
+        // If client is being created, wait for it
+        const pending = pendingClients.get(key);
+        if (pending)
+            return pending;
+        // Create new client and cache it
+        const clientOpts = { ...cockpitOptions };
+        if (tenant !== undefined)
+            clientOpts.tenant = tenant;
+        const clientPromise = CockpitAPI(clientOpts);
+        pendingClients.set(key, clientPromise);
+        try {
+            const client = await clientPromise;
+            clientPool.set(key, client);
+            return client;
+        }
+        finally {
+            pendingClients.delete(key);
+        }
+    }
+    return async ({ document, variables, context }) => {
+        // Extract tenant from context
+        const tenant = extractTenant
+            ? extractTenant(context)
+            : defaultTenantExtractor(context, tenantHeader);
+        // Get or create pooled client
+        const cockpit = await getOrCreateClient(tenant);
+        // Execute GraphQL query
+        return cockpit.graphQL(document, variables);
+    };
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * GraphQL Schema Stitching utilities for Cockpit CMS
+ *
+ * This module requires `@graphql-tools/wrap` as a peer dependency.
+ * Install it with: npm install @graphql-tools/wrap
+ *
+ * @example
+ * ```typescript
+ * import { makeCockpitGraphQLSchema } from "@unchainedshop/cockpit-api/schema";
+ *
+ * // Create a stitchable schema from Cockpit
+ * const cockpitSchema = await makeCockpitGraphQLSchema({
+ *   tenantHeader: "x-cockpit-space",  // Header for multi-tenant support
+ *   filterMutations: true,             // Read-only by default
+ * });
+ *
+ * // Use with @graphql-tools/stitch
+ * import { stitchSchemas } from "@graphql-tools/stitch";
+ *
+ * const gatewaySchema = stitchSchemas({
+ *   subschemas: [{ schema: cockpitSchema }],
+ * });
+ * ```
+ */
+export { makeCockpitGraphQLSchema } from "./schema-builder.ts";
+export { createRemoteExecutor, type MakeCockpitSchemaOptions, type CockpitExecutorContext, type ExecutorRequest, type RemoteExecutor, } from "./executor.ts";

package/dist/schema/index.js

@@ -0,0 +1,26 @@
+/**
+ * GraphQL Schema Stitching utilities for Cockpit CMS
+ *
+ * This module requires `@graphql-tools/wrap` as a peer dependency.
+ * Install it with: npm install @graphql-tools/wrap
+ *
+ * @example
+ * ```typescript
+ * import { makeCockpitGraphQLSchema } from "@unchainedshop/cockpit-api/schema";
+ *
+ * // Create a stitchable schema from Cockpit
+ * const cockpitSchema = await makeCockpitGraphQLSchema({
+ *   tenantHeader: "x-cockpit-space",  // Header for multi-tenant support
+ *   filterMutations: true,             // Read-only by default
+ * });
+ *
+ * // Use with @graphql-tools/stitch
+ * import { stitchSchemas } from "@graphql-tools/stitch";
+ *
+ * const gatewaySchema = stitchSchemas({
+ *   subschemas: [{ schema: cockpitSchema }],
+ * });
+ * ```
+ */
+export { makeCockpitGraphQLSchema } from "./schema-builder.js";
+export { createRemoteExecutor, } from "./executor.js";

package/dist/schema/schema-builder.d.ts

@@ -0,0 +1,42 @@
+/**
+ * GraphQL schema builder for Cockpit CMS schema stitching
+ */
+import type { GraphQLSchema } from "graphql";
+import { type MakeCockpitSchemaOptions } from "./executor.ts";
+/**
+ * Creates a GraphQL schema from Cockpit's introspected schema for schema stitching
+ *
+ * Requires `@graphql-tools/wrap` as a peer dependency.
+ *
+ * @example
+ * ```typescript
+ * import { makeCockpitGraphQLSchema } from "@unchainedshop/cockpit-api/schema";
+ *
+ * // Basic usage - creates read-only schema with tenant header support
+ * const schema = await makeCockpitGraphQLSchema();
+ *
+ * // Custom configuration
+ * const schema = await makeCockpitGraphQLSchema({
+ *   tenantHeader: "x-cockpit-space",
+ *   filterMutations: true,
+ *   cockpitOptions: {
+ *     endpoint: "https://cms.example.com/api/graphql",
+ *   },
+ * });
+ *
+ * // Use with schema stitching
+ * import { stitchSchemas } from "@graphql-tools/stitch";
+ *
+ * const gatewaySchema = stitchSchemas({
+ *   subschemas: [
+ *     { schema: await makeCockpitGraphQLSchema() },
+ *     // ... other subschemas
+ *   ],
+ * });
+ * ```
+ *
+ * @param options - Configuration options
+ * @returns Promise resolving to the GraphQL schema
+ * @throws Error if @graphql-tools/wrap is not installed
+ */
+export declare function makeCockpitGraphQLSchema(options?: MakeCockpitSchemaOptions): Promise<GraphQLSchema>;

package/dist/schema/schema-builder.js

@@ -0,0 +1,77 @@
+/**
+ * GraphQL schema builder for Cockpit CMS schema stitching
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createRemoteExecutor, } from "./executor.js";
+/**
+ * Creates a GraphQL schema from Cockpit's introspected schema for schema stitching
+ *
+ * Requires `@graphql-tools/wrap` as a peer dependency.
+ *
+ * @example
+ * ```typescript
+ * import { makeCockpitGraphQLSchema } from "@unchainedshop/cockpit-api/schema";
+ *
+ * // Basic usage - creates read-only schema with tenant header support
+ * const schema = await makeCockpitGraphQLSchema();
+ *
+ * // Custom configuration
+ * const schema = await makeCockpitGraphQLSchema({
+ *   tenantHeader: "x-cockpit-space",
+ *   filterMutations: true,
+ *   cockpitOptions: {
+ *     endpoint: "https://cms.example.com/api/graphql",
+ *   },
+ * });
+ *
+ * // Use with schema stitching
+ * import { stitchSchemas } from "@graphql-tools/stitch";
+ *
+ * const gatewaySchema = stitchSchemas({
+ *   subschemas: [
+ *     { schema: await makeCockpitGraphQLSchema() },
+ *     // ... other subschemas
+ *   ],
+ * });
+ * ```
+ *
+ * @param options - Configuration options
+ * @returns Promise resolving to the GraphQL schema
+ * @throws Error if @graphql-tools/wrap is not installed
+ */
+export async function makeCockpitGraphQLSchema(options = {}) {
+    // Dynamic import to handle optional peer dependency
+    let wrapModule;
+    try {
+        wrapModule = (await import(__rewriteRelativeImportExtension("@graphql-tools/wrap")));
+    }
+    catch {
+        throw new Error("Cockpit: @graphql-tools/wrap is required for schema stitching. " +
+            "Install it with: npm install @graphql-tools/wrap");
+    }
+    const { schemaFromExecutor, wrapSchema, FilterRootFields } = wrapModule;
+    const { filterMutations = true, transforms = [] } = options;
+    const executor = createRemoteExecutor(options);
+    // Build the list of transforms
+    const allTransforms = [];
+    // Add mutation filter if enabled (default)
+    if (filterMutations) {
+        allTransforms.push(new FilterRootFields((operationName) => operationName !== "Mutation"));
+    }
+    // Add user-provided transforms
+    allTransforms.push(...transforms);
+    // Introspect and wrap the schema
+    const introspectedSchema = await schemaFromExecutor(executor);
+    return wrapSchema({
+        schema: introspectedSchema,
+        executor,
+        transforms: allTransforms,
+    });
+}

package/dist/transformers/asset-path.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Asset path transformer for fixing Cockpit CMS storage paths
+ */
+import type { ResponseTransformer } from "./image-path.ts";
+export interface AssetPathConfig {
+    /** Base URL of the Cockpit CMS (origin only) */
+    baseUrl: string;
+    /** Tenant name for multi-tenant setups */
+    tenant?: string;
+}
+/**
+ * Transforms asset paths in a JSON string.
+ * This is the core transformation logic used by the transformer.
+ */
+export declare function transformAssetPaths(jsonString: string, config: AssetPathConfig): string;
+/**
+ * Creates a transformer that fixes asset paths in responses.
+ * Use this when you only need asset path fixing without page link resolution.
+ */
+export declare function createAssetPathTransformer(config: AssetPathConfig): ResponseTransformer;

package/dist/transformers/asset-path.js

@@ -0,0 +1,40 @@
+/**
+ * Asset path transformer for fixing Cockpit CMS storage paths
+ */
+import { logger } from "../cockpit-logger.js";
+/**
+ * Transforms asset paths in a JSON string.
+ * This is the core transformation logic used by the transformer.
+ */
+export function transformAssetPaths(jsonString, config) {
+    const { baseUrl, tenant } = config;
+    const tenantUrl = `${baseUrl}${tenant !== undefined ? `/:${tenant}` : ""}`;
+    return (jsonString
+        // Fix asset paths in "path" fields
+        .replace(/"path":"\//g, `"path":"${tenantUrl}/storage/uploads/`)
+        // Fix storage paths in src attributes
+        .replace(/src=\\"(\/[^"]*?)storage/gi, `src=\\"${baseUrl}$1storage`)
+        // Fix storage paths in href attributes
+        .replace(/href=\\"(\/[^"]*?)storage/gi, `href=\\"${baseUrl}$1storage`)
+        // Fix duplicate storage/uploads paths (cleanup)
+        .replace(/\/storage\/uploads\/storage\/uploads\//g, `/storage/uploads/`));
+}
+/**
+ * Creates a transformer that fixes asset paths in responses.
+ * Use this when you only need asset path fixing without page link resolution.
+ */
+export function createAssetPathTransformer(config) {
+    return {
+        transform(originalResponse) {
+            try {
+                const jsonString = JSON.stringify(originalResponse);
+                const fixedString = transformAssetPaths(jsonString, config);
+                return JSON.parse(fixedString);
+            }
+            catch (error) {
+                logger.warn("Cockpit: Failed to transform asset paths", error);
+                return originalResponse;
+            }
+        },
+    };
+}

package/dist/transformers/compose.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transformer composition utilities
+ */
+import type { ResponseTransformer } from "./image-path.ts";
+/**
+ * Composes multiple transformers into a single transformer
+ * Transforms are applied left to right
+ */
+export declare function composeTransformers(...transformers: ResponseTransformer[]): ResponseTransformer;

package/dist/transformers/compose.js

@@ -0,0 +1,14 @@
+/**
+ * Transformer composition utilities
+ */
+/**
+ * Composes multiple transformers into a single transformer
+ * Transforms are applied left to right
+ */
+export function composeTransformers(...transformers) {
+    return {
+        transform(response) {
+            return transformers.reduce((result, transformer) => transformer.transform(result), response);
+        },
+    };
+}

package/dist/transformers/image-path.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Image path transformer for fixing asset paths and page links
+ *
+ * This module provides the main transformer that combines asset path fixing
+ * and page link resolution in a single efficient pass. For individual
+ * transformers, see asset-path.ts and page-link.ts.
+ */
+import { type AssetPathConfig } from "./asset-path.ts";
+export interface ResponseTransformer {
+    transform<T>(response: T): T;
+}
+export declare const identityTransformer: ResponseTransformer;
+export interface ImagePathTransformerConfig extends AssetPathConfig {
+    /** Route replacements map (pages://id -> route) */
+    replacements: Record<string, string>;
+}
+/**
+ * Creates a transformer that fixes image paths and resolves page links.
+ * Uses a single JSON stringify/parse cycle for efficiency.
+ */
+export declare function createImagePathTransformer(config: ImagePathTransformerConfig): ResponseTransformer;
+/**
+ * Legacy export for backwards compatibility
+ * @deprecated Use createImagePathTransformer instead
+ */
+export declare function FixImagePaths(endpoint: string, replacements: Record<string, string>, tenant?: string): {
+    transformResult<T>(originalResponse: T): T;
+};

package/dist/transformers/image-path.js

@@ -0,0 +1,60 @@
+/**
+ * Image path transformer for fixing asset paths and page links
+ *
+ * This module provides the main transformer that combines asset path fixing
+ * and page link resolution in a single efficient pass. For individual
+ * transformers, see asset-path.ts and page-link.ts.
+ */
+import { logger } from "../cockpit-logger.js";
+import { transformAssetPaths } from "./asset-path.js";
+import { transformPageLinks } from "./page-link.js";
+export const identityTransformer = {
+    transform(response) {
+        return response;
+    },
+};
+/**
+ * Creates a transformer that fixes image paths and resolves page links.
+ * Uses a single JSON stringify/parse cycle for efficiency.
+ */
+export function createImagePathTransformer(config) {
+    const { baseUrl, tenant, replacements } = config;
+    // Build asset config, only including tenant if defined
+    const assetConfig = { baseUrl };
+    if (tenant !== undefined)
+        assetConfig.tenant = tenant;
+    return {
+        transform(originalResponse) {
+            try {
+                // Single stringify for efficiency
+                let jsonString = JSON.stringify(originalResponse);
+                // Apply asset path transformations
+                jsonString = transformAssetPaths(jsonString, assetConfig);
+                // Apply page link transformations
+                jsonString = transformPageLinks(jsonString, replacements);
+                return JSON.parse(jsonString);
+            }
+            catch (error) {
+                logger.warn("Cockpit: Failed to transform response", error);
+                return originalResponse;
+            }
+        },
+    };
+}
+/**
+ * Legacy export for backwards compatibility
+ * @deprecated Use createImagePathTransformer instead
+ */
+export function FixImagePaths(endpoint, replacements, tenant) {
+    const baseUrl = new URL(endpoint).origin;
+    const config = {
+        baseUrl,
+        replacements,
+    };
+    if (tenant !== undefined)
+        config.tenant = tenant;
+    const transformer = createImagePathTransformer(config);
+    return {
+        transformResult: transformer.transform.bind(transformer),
+    };
+}

package/dist/transformers/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Transformer exports
+ */
+export type { ResponseTransformer } from "./image-path.ts";
+export { identityTransformer, createImagePathTransformer, FixImagePaths, } from "./image-path.ts";
+export { composeTransformers } from "./compose.ts";
+export { createAssetPathTransformer, transformAssetPaths, type AssetPathConfig, } from "./asset-path.ts";
+export { createPageLinkTransformer, transformPageLinks } from "./page-link.ts";

package/dist/transformers/index.js

@@ -0,0 +1,9 @@
+/**
+ * Transformer exports
+ */
+export { identityTransformer, createImagePathTransformer, 
+// eslint-disable-next-line @typescript-eslint/no-deprecated
+FixImagePaths, } from "./image-path.js";
+export { composeTransformers } from "./compose.js";
+export { createAssetPathTransformer, transformAssetPaths, } from "./asset-path.js";
+export { createPageLinkTransformer, transformPageLinks } from "./page-link.js";

package/dist/transformers/page-link.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Page link transformer for resolving pages://id links
+ */
+import type { ResponseTransformer } from "./image-path.ts";
+/**
+ * Transforms page links in a JSON string.
+ * This is the core transformation logic used by the transformer.
+ *
+ * @param jsonString - The JSON string to transform
+ * @param replacements - Map of pages://id -> actual route
+ * @returns Transformed JSON string with page links resolved
+ */
+export declare function transformPageLinks(jsonString: string, replacements: Record<string, string>): string;
+/**
+ * Creates a transformer that resolves page links (pages://id -> route).
+ * Use this when you only need page link resolution without asset path fixing.
+ */
+export declare function createPageLinkTransformer(replacements: Record<string, string>): ResponseTransformer;

package/dist/transformers/page-link.js

@@ -0,0 +1,45 @@
+/**
+ * Page link transformer for resolving pages://id links
+ */
+import { logger } from "../cockpit-logger.js";
+/**
+ * Escapes regex special characters in a string
+ */
+const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * Transforms page links in a JSON string.
+ * This is the core transformation logic used by the transformer.
+ *
+ * @param jsonString - The JSON string to transform
+ * @param replacements - Map of pages://id -> actual route
+ * @returns Transformed JSON string with page links resolved
+ */
+export function transformPageLinks(jsonString, replacements) {
+    const keys = Object.keys(replacements);
+    if (keys.length === 0)
+        return jsonString;
+    const pattern = new RegExp(keys.map(escapeRegex).join("|"), "g");
+    return jsonString.replace(pattern, (match) => replacements[match] ?? match);
+}
+/**
+ * Creates a transformer that resolves page links (pages://id -> route).
+ * Use this when you only need page link resolution without asset path fixing.
+ */
+export function createPageLinkTransformer(replacements) {
+    return {
+        transform(originalResponse) {
+            const keys = Object.keys(replacements);
+            if (keys.length === 0)
+                return originalResponse;
+            try {
+                const jsonString = JSON.stringify(originalResponse);
+                const fixedString = transformPageLinks(jsonString, replacements);
+                return JSON.parse(fixedString);
+            }
+            catch (error) {
+                logger.warn("Cockpit: Failed to transform page links", error);
+                return originalResponse;
+            }
+        },
+    };
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Utility exports
+ */
+export { getTenantIds, resolveApiKey } from "./tenant.ts";
+export { generateCmsRouteReplacements, generateCollectionAndSingletonSlugRouteMap, } from "./route-map.ts";