@takeshape/ssg 11.143.2 → 11.154.1

package/dist/generate/generate.d.ts

@@ -1,21 +0,0 @@
-import { type Config, type FileLoader, type PaginateConfig, type RouteConfig, type SyncFileLoader } from '../config.ts';
-import type { Data, GraphQLConnector, RenderedPage } from '../types.ts';
-import type { GenerateResult, GetPaginatedData, RenderContext } from './types.ts';
-export declare function calculatePages(total: number, pageSize: number): number;
-export declare function hasListPageConfig(paginate: PaginateConfig): boolean;
-export declare function hasItemPageConfig(route: RouteConfig): boolean;
-type RenderPaginatedRoute = (route: RouteConfig, context: Data) => Promise<RenderedPage[]>;
-export declare function renderPaginatedTemplate(generateContext: RenderContext, getPaginatedData: GetPaginatedData): RenderPaginatedRoute;
-export type GenerateParams = {
-    fileLoader: FileLoader;
-    connector: GraphQLConnector;
-    templateFileLoader: SyncFileLoader;
-};
-export type GenerateRouteParams = {
-    routeName: string;
-    locale?: string;
-    contentId?: string;
-} & GenerateParams;
-export declare function generateRoute(config: Config, params: GenerateRouteParams): Promise<GenerateResult>;
-export default function generate(config: Config, params: GenerateParams): Promise<GenerateResult>;
-export {};

package/dist/generate/generate.js

@@ -1,300 +0,0 @@
-import { createAsyncWritable, pump } from '@takeshape/streams';
-import asyncIteratorToStream from 'async-iterator-to-stream';
-import BbPromise from 'bluebird';
-import compose from 'lodash/fp/compose.js';
-import flatten from 'lodash/fp/flatten.js';
-import partition from 'lodash/partition.js';
-import uniqBy from 'lodash/uniqBy.js';
-import { obj as Pumpify } from 'pumpify';
-import compressHtml from "../compress-html.js";
-import { localizeConfig } from "../config.js";
-import GraphQLError from "../errors/graphql-error.js";
-import PaginationError from "../errors/pagination-error.js";
-import { getClientSchema, getQueryIterator, withQueryTransforms } from "../graphql/index.js";
-import gzipContents from "../gzip.js";
-import nunjucks from "../nunjucks.js";
-import { joinPath } from "../paths.js";
-import resolveContext, { resolveGraphQLConfig } from "../resolve-context.js";
-import { combineContext, getItemContext, getListPageContext } from "./context.js";
-import { createItemRenderArgs, createListRenderArgs } from "./streams.js";
-const pageSize = Number(process.env.TS_EXPERIMENTAL_PAGE_SIZE) || 100;
-const getPaginatedData = async (generateContext, paginate, context) => {
-    const { connector, fileLoader, srcPath, clientSchema, stats } = generateContext;
-    if (paginate.data) {
-        const config = await resolveGraphQLConfig(paginate.data, {
-            fileLoader,
-            srcPath
-        });
-        const res = await getQueryIterator(clientSchema, config.query, connector, {
-            pageSize,
-            variables: config.variables,
-            source: config.source,
-            stats
-        });
-        return {
-            iterable: res.iterator(),
-            total: res.total
-        };
-    }
-    if (paginate.property) {
-        const itemsArray = context[paginate.property];
-        if (itemsArray) {
-            const filtered = itemsArray.filter(Boolean);
-            return {
-                iterable: filtered,
-                total: filtered.length
-            };
-        }
-    }
-    return null;
-};
-export function calculatePages(total, pageSize) {
-    return Math.ceil(total / pageSize);
-}
-export function hasListPageConfig(paginate) {
-    return Boolean(paginate.pageSize && paginate.template && paginate.path);
-}
-export function hasItemPageConfig(route) {
-    return Boolean(route.path && route.template);
-}
-export function renderPaginatedTemplate(generateContext, getPaginatedData) {
-    const { renderTemplate, stats, pathPrefix } = generateContext;
-    return async (route, context) => {
-        const { paginate } = route;
-        if (!paginate) {
-            throw new Error('Route missing paginate');
-        }
-        const shouldRenderItemPage = hasItemPageConfig(route);
-        const shouldRenderListPage = hasListPageConfig(paginate);
-        try {
-            const paginatedData = await getPaginatedData(generateContext, paginate, context);
-            if (!paginatedData) {
-                return [];
-            }
-            const totalPages = calculatePages(paginatedData.total, paginate.pageSize);
-            const routeContext = {
-                pathPrefix,
-                totalPages,
-                renderTemplate,
-                route,
-                context
-            };
-            const pages = [];
-            const writePages = () => createAsyncWritable(async (args) => {
-                pages.push(await renderTemplate.apply(null, args));
-            }, 100);
-            const writeStreams = [];
-            if (shouldRenderItemPage) {
-                writeStreams.push(new Pumpify(createItemRenderArgs(routeContext, getItemContext, stats), writePages()));
-            }
-            if (shouldRenderListPage) {
-                writeStreams.push(new Pumpify(createListRenderArgs(routeContext, getListPageContext), writePages()));
-            }
-            const data = asyncIteratorToStream.obj(paginatedData.iterable);
-            await BbPromise.map(writeStreams, async (writeStream) => pump(data, writeStream));
-            return pages;
-        }
-        catch (e) {
-            if (e instanceof GraphQLError || e instanceof PaginationError) {
-                throw e;
-            }
-            throw new Error(`Failed to render paginated route ${route.path}\n ${e.name}: ${e.message}`);
-        }
-    };
-}
-async function resolveRouteContext(generateContext, route) {
-    const { srcPath, connector, fileLoader, stats } = generateContext;
-    const contextConfig = route.context;
-    return contextConfig
-        ? resolveContext({
-            contextConfig,
-            srcPath,
-            connector,
-            fileLoader,
-            stats,
-            route
-        })
-        : {};
-}
-function renderTemplates(generateContext) {
-    const { renderTemplate, config, globalContext, pathPrefix } = generateContext;
-    return async (routes) => BbPromise.map(routes, async (route) => {
-        const routeContext = await resolveRouteContext(generateContext, route);
-        const context = combineContext(config.env, globalContext, route, routeContext);
-        const path = joinPath(pathPrefix, route.path);
-        const page = await renderTemplate(path, route.template, context);
-        return {
-            pages: [page],
-            order: route._routeOrder
-        };
-    });
-}
-function renderPaginatedTemplates(generateContext) {
-    const render = renderPaginatedTemplate(generateContext, getPaginatedData);
-    return async (routes) => {
-        const { config, globalContext } = generateContext;
-        return BbPromise.map(routes, async (route) => {
-            const routeContext = await resolveRouteContext(generateContext, route);
-            const renderedPages = await render(route, combineContext(config.env, globalContext, route, routeContext));
-            return {
-                pages: renderedPages,
-                order: route._routeOrder
-            };
-        });
-    };
-}
-async function generatePages(config, generateContext) {
-    const routeEntries = Object.entries(config.routes);
-    const routesWithOrder = routeEntries.map(([, route], index) => ({ ...route, _routeOrder: index }));
-    const [paginatedRouteConfigs, singleRouteConfigs] = partition(routesWithOrder, 'paginate');
-    const renderContext = {
-        ...generateContext,
-        globalContext: {
-            ...(config.context
-                ? await resolveContext({
-                    contextConfig: config.context,
-                    srcPath: generateContext.srcPath,
-                    connector: generateContext.connector,
-                    fileLoader: generateContext.fileLoader,
-                    stats: generateContext.stats
-                })
-                : {}),
-            locale: config.locale
-        }
-    };
-    const singleRoutes = await renderTemplates(renderContext)(singleRouteConfigs);
-    const paginatedRoutes = await renderPaginatedTemplates(renderContext)(paginatedRouteConfigs);
-    const allRoutes = singleRoutes.concat(paginatedRoutes);
-    const sortedRoutes = allRoutes.sort((a, b) => a.order - b.order);
-    const allPages = sortedRoutes.flatMap((route) => route.pages);
-    // First route wins
-    return uniqBy(allPages, 'path');
-}
-function removeListingPageConfig(routeConfig) {
-    if (routeConfig.paginate) {
-        const { template, ...rest } = routeConfig.paginate;
-        if (template) {
-            return {
-                ...routeConfig,
-                paginate: {
-                    ...rest
-                }
-            };
-        }
-    }
-    return routeConfig;
-}
-export async function generateRoute(config, params) {
-    const { connector, fileLoader, templateFileLoader, routeName, locale, contentId } = params;
-    const srcPath = config.templatePath;
-    const stats = {
-        pagesGenerated: 0,
-        warnings: []
-    };
-    if (config.usageStats) {
-        stats.contentUsage = {};
-    }
-    const clientSchema = await getClientSchema(connector);
-    const { locales } = config;
-    const localizedConfig = locales && locale && locales[locale] ? localizeConfig(config, locale) : config;
-    const routeConfig = config.routes[routeName];
-    if (!routeConfig) {
-        return { pages: [], stats };
-    }
-    const globalContext = config.context
-        ? await resolveContext({
-            contextConfig: config.context,
-            srcPath,
-            connector,
-            fileLoader,
-            stats
-        })
-        : {};
-    const renderContext = {
-        renderTemplate: nunjucks(templateFileLoader, localizedConfig, stats),
-        pathPrefix: localizedConfig.pathPrefix || '',
-        fileLoader,
-        connector: withQueryTransforms(connector, clientSchema, {
-            locale,
-            contentId,
-            usage: config.usageStats
-        }),
-        clientSchema,
-        srcPath,
-        stats,
-        config,
-        globalContext
-    };
-    const routeWithOrder = { ...routeConfig, _routeOrder: 0 };
-    const routes = await (routeConfig.paginate
-        ? renderPaginatedTemplates(renderContext)([{ ...removeListingPageConfig(routeConfig), _routeOrder: 0 }])
-        : renderTemplates(renderContext)([routeWithOrder]));
-    // Flatten routes to pages since there's only one route
-    const pages = routes.flatMap((route) => route.pages);
-    return {
-        pages,
-        stats
-    };
-}
-const identity = (obj) => obj;
-function getRenderTemplateDecorator(config) {
-    const decorators = [];
-    if (config.gzip) {
-        decorators.push(gzipContents);
-    }
-    if (config.htmlCompression?.enabled) {
-        decorators.push(compressHtml(config.htmlCompression));
-    }
-    return decorators.length ? compose(decorators) : identity;
-}
-export default async function generate(config, params) {
-    const { connector, fileLoader, templateFileLoader } = params;
-    const srcPath = config.templatePath;
-    const stats = {
-        pagesGenerated: 0,
-        warnings: []
-    };
-    if (config.usageStats) {
-        stats.contentUsage = {};
-    }
-    const clientSchema = await getClientSchema(connector);
-    const generateContext = {
-        pathPrefix: '',
-        clientSchema,
-        srcPath,
-        stats,
-        config,
-        fileLoader
-    };
-    let pages;
-    const renderTemplateDecorator = getRenderTemplateDecorator(config);
-    const { locales } = config;
-    if (locales) {
-        const localizedPages = await BbPromise.map(Object.keys(locales), async (locale) => {
-            const localizedConfig = localizeConfig(config, locale);
-            return generatePages(localizedConfig, {
-                ...generateContext,
-                renderTemplate: renderTemplateDecorator(nunjucks(templateFileLoader, localizedConfig, stats)),
-                pathPrefix: localizedConfig.pathPrefix,
-                connector: withQueryTransforms(connector, clientSchema, {
-                    locale,
-                    usage: config.usageStats
-                })
-            });
-        });
-        pages = flatten(localizedPages);
-    }
-    else {
-        pages = await generatePages(config, {
-            ...generateContext,
-            renderTemplate: renderTemplateDecorator(nunjucks(templateFileLoader, config, stats)),
-            connector: withQueryTransforms(connector, clientSchema, {
-                usage: config.usageStats
-            })
-        });
-    }
-    return {
-        pages,
-        stats
-    };
-}

package/dist/generate/index.d.ts

@@ -1 +0,0 @@
-export { default, generateRoute } from './generate.ts';

package/dist/generate/index.js

@@ -1 +0,0 @@
-export { default, generateRoute } from "./generate.js";

package/dist/generate/streams.d.ts

@@ -1,7 +0,0 @@
-import { Transform } from 'node:stream';
-import type { Stats } from '../types.ts';
-import type { GetItemContext, GetListPageContext } from './context.ts';
-import type { PathItem, PathItemContext, RouteContext } from './types.ts';
-export declare function readPageBuffer(buffer: PathItem[], last: boolean): PathItemContext;
-export declare function createItemRenderArgs(routeContext: RouteContext, getItemContext: GetItemContext, stats: Stats): Transform;
-export declare function createListRenderArgs(routeContext: RouteContext, getListPageContext: GetListPageContext): Transform;

package/dist/generate/streams.js

@@ -1,88 +0,0 @@
-import { Transform } from 'node:stream';
-import { formatPath } from '@takeshape/routing';
-import { joinPath } from "../paths.js";
-import { generateWarning, recordContentUsage } from "../stats.js";
-export function readPageBuffer(buffer, last) {
-    const { length } = buffer;
-    const offset = length === 1 || (length < 3 && !last) ? -1 : 0;
-    return {
-        previous: buffer[offset],
-        current: buffer[1 + offset],
-        next: buffer[2 + offset]
-    };
-}
-function handlePathWarnings(stats, warnings, route) {
-    for (const variable of warnings) {
-        generateWarning(stats, 'renderPaginatedTemplate', `${route.path} variable ${variable} resolves to undefined.`);
-    }
-}
-export function createItemRenderArgs(routeContext, getItemContext, stats) {
-    const { route, context, pathPrefix } = routeContext;
-    const buffer = [];
-    const createArgs = (last) => {
-        const itemContext = getItemContext(route, context, readPageBuffer(buffer, last));
-        return [itemContext.currentPath, route.template, itemContext];
-    };
-    return new Transform({
-        objectMode: true,
-        transform(obj, _, next) {
-            const { path, warnings } = formatPath(route.path, obj);
-            const currentPath = joinPath(pathPrefix, path);
-            if (warnings.length) {
-                handlePathWarnings(stats, warnings, route);
-            }
-            else {
-                buffer.push({ item: obj, path: currentPath });
-                if (buffer.length > 1) {
-                    this.push(createArgs(false));
-                    if (buffer.length > 2) {
-                        buffer.shift();
-                    }
-                }
-                recordContentUsage(stats, obj, currentPath);
-            }
-            next();
-        },
-        flush(done) {
-            if (buffer.length) {
-                this.push(createArgs(true));
-            }
-            done();
-        }
-    });
-}
-export function createListRenderArgs(routeContext, getListPageContext) {
-    const { pathPrefix, route } = routeContext;
-    const { paginate } = route;
-    if (!paginate) {
-        throw new Error('Cannot create list page for non-paginated route');
-    }
-    const { template, pageSize } = paginate;
-    if (!template) {
-        throw new Error('Cannot create list page missing paginate.template');
-    }
-    let buffer = [];
-    let page = 1;
-    const createArgs = () => {
-        const context = getListPageContext(buffer, page, routeContext);
-        page++;
-        buffer = [];
-        return [joinPath(pathPrefix, context.currentPath), template, context];
-    };
-    return new Transform({
-        objectMode: true,
-        transform(obj, _, next) {
-            buffer.push(obj);
-            if (buffer.length === pageSize) {
-                this.push(createArgs());
-            }
-            next();
-        },
-        flush(done) {
-            if (buffer.length) {
-                this.push(createArgs());
-            }
-            done();
-        }
-    });
-}

package/dist/generate/types.d.ts

@@ -1,54 +0,0 @@
-import type { GraphQLSchema } from 'graphql';
-import type { Config, FileLoader, PaginateConfig, RouteConfig, RoutesMap } from '../config.ts';
-import type { Data, GraphQLConnector, RenderedPage, RenderTemplate, Stats } from '../types.ts';
-export type GenerateResult = {
-    pages: RenderedPage[];
-    stats: Stats;
-};
-export type GenerateContext = {
-    config: Config;
-    pathPrefix: string;
-    clientSchema: GraphQLSchema;
-    srcPath: string;
-    stats: Stats;
-    renderTemplate: RenderTemplate;
-    connector: GraphQLConnector;
-    fileLoader: FileLoader;
-};
-export type RenderContext = {
-    globalContext: Data;
-} & GenerateContext;
-export type RouteContext = {
-    pathPrefix: string;
-    totalPages: number;
-    renderTemplate: RenderTemplate;
-    route: RouteConfig;
-    context: Data;
-};
-export type PathItem = {
-    item: Data;
-    path: string;
-};
-export type PathItemContext = {
-    previous?: PathItem;
-    current: PathItem;
-    next?: PathItem;
-};
-export type ItemBuffer = {
-    push(item: Data, path: string): void;
-    done(): Promise<RenderedPage[]>;
-};
-export type ListPageBuffer = {
-    push(item: Data): void;
-    done(): Promise<RenderedPage[]>;
-};
-export type ResolveRoutesContextParams = {
-    routes: RoutesMap;
-    srcPath: string;
-    connector: GraphQLConnector;
-    stats: Stats;
-};
-export type GetPaginatedData = (generateContext: GenerateContext, paginate: PaginateConfig, context: Data) => Promise<{
-    iterable: Iterable<Data>;
-    total: number;
-} | null>;

package/dist/generate/types.js

@@ -1 +0,0 @@
-export {};

package/dist/graphql/analyze.d.ts

@@ -1,28 +0,0 @@
-import { type DocumentNode, type GraphQLSchema } from 'graphql';
-import { type Config, type FileLoader, type RouteInfo } from '../config.ts';
-type FileInfo = {
-    body: string;
-    name: string;
-};
-type Usage = {
-    file: string;
-    location: {
-        line: number;
-        column: number;
-    };
-};
-type UsageInfo = {
-    type: string;
-    usage: Usage[];
-};
-type UsageInfoMap = Record<string, Record<string, UsageInfo>>;
-export declare function getFieldUsage(queryAst: DocumentNode, schema: GraphQLSchema, fileInfo: FileInfo): UsageInfoMap;
-export declare function detectTypes(queryAst: DocumentNode, schema: GraphQLSchema): Set<string>;
-export type TypeUsage = Record<string, RouteInfo[]>;
-export type GetTypeUsageParams = {
-    config: Config;
-    schema: GraphQLSchema;
-    fileLoader: FileLoader;
-};
-export declare function getTypeUsage({ config, schema, fileLoader }: GetTypeUsageParams): Promise<TypeUsage>;
-export {};

package/dist/graphql/analyze.js

@@ -1,87 +0,0 @@
-import path from 'node:path';
-import BbPromise from 'bluebird';
-import { getLocation, isListType, isObjectType, parse, Source, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
-import { getGraphQLQueries } from "../config.js";
-import { getFields, getItemType } from "./query.js";
-const startLocation = { line: 1, column: 1 };
-export function getFieldUsage(queryAst, schema, fileInfo) {
-    const typeInfo = new TypeInfo(schema);
-    const result = {};
-    const visitor = {
-        Field: {
-            enter(node) {
-                const field = typeInfo.getFieldDef();
-                if (!field) {
-                    return;
-                }
-                const type = getItemType(field.type);
-                const fields = getFields(type);
-                const fieldInfo = result[type.toString()] || {};
-                if (fields && node.selectionSet) {
-                    for (const selection of node.selectionSet.selections) {
-                        if (selection.kind === 'Field' || selection.kind === 'FragmentSpread') {
-                            const name = selection.name.value;
-                            const usage = fieldInfo[name] ? fieldInfo[name].usage : [];
-                            const source = new Source(fileInfo.body, fileInfo.name, startLocation);
-                            fieldInfo[name] = {
-                                type: fields[name].type.toString(),
-                                usage: usage.concat({
-                                    file: fileInfo.name,
-                                    location: selection.loc ? getLocation(source, selection.loc.start) : startLocation
-                                })
-                            };
-                        }
-                    }
-                    result[type.toString()] = fieldInfo;
-                }
-            }
-        }
-    };
-    visit(queryAst, visitWithTypeInfo(typeInfo, visitor));
-    return result;
-}
-export function detectTypes(queryAst, schema) {
-    const typeInfo = new TypeInfo(schema);
-    const result = new Set();
-    const queryType = schema.getQueryType();
-    if (!queryType) {
-        throw new Error('Invalid schema has no queries');
-    }
-    const topLevelQueries = new Set(Object.keys(queryType.getFields()));
-    const visitor = {
-        Field: {
-            enter(node) {
-                if (topLevelQueries.has(node.name.value)) {
-                    const field = typeInfo.getFieldDef();
-                    if (field) {
-                        const fieldType = field.type;
-                        if (isObjectType(fieldType)) {
-                            const fields = fieldType.getFields();
-                            if (fields.items && isListType(fields.items.type)) {
-                                result.add(fields.items.type.ofType.toString());
-                            }
-                            else {
-                                result.add(fieldType.toString());
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    };
-    visit(queryAst, visitWithTypeInfo(typeInfo, visitor));
-    return result;
-}
-export async function getTypeUsage({ config, schema, fileLoader }) {
-    const queries = getGraphQLQueries(config);
-    return BbPromise.reduce(queries, async (result, routeQuery) => {
-        const { filePath, ...info } = routeQuery;
-        const queryString = await fileLoader(path.join(config.templatePath, filePath));
-        const types = detectTypes(parse(queryString), schema);
-        for (const type of types) {
-            result[type] ||= [];
-            result[type].push(info);
-        }
-        return result;
-    }, {});
-}

package/dist/graphql/ast.d.ts

@@ -1,19 +0,0 @@
-import type { ArgumentNode, DefinitionNode, DocumentNode, FieldNode, OperationDefinitionNode, SelectionNode, SelectionSetNode, VariableDefinitionNode } from 'graphql';
-export type Arg = {
-    name: string;
-    value: string;
-};
-export type Var = {
-    name: string;
-    type: string;
-};
-export declare function createArgument({ name, value }: Arg): ArgumentNode;
-export declare function createVariableDefinition({ name, type }: Var): VariableDefinitionNode;
-export declare function createSelectionSet(selections: SelectionNode[]): SelectionSetNode;
-export declare function createField(name: string): FieldNode;
-export declare function isQueryNode(node: DefinitionNode): node is OperationDefinitionNode;
-export declare function findQuery(ast: DocumentNode): OperationDefinitionNode | undefined;
-export declare function updateQuery(ast: DocumentNode, update: (query: OperationDefinitionNode) => OperationDefinitionNode): DocumentNode;
-export declare function addQueryVariables(variables: Var[], ast: DocumentNode): DocumentNode;
-export declare function wrapSelectionSet(selectionSet: SelectionSetNode, name: string, args?: ArgumentNode[]): SelectionSetNode;
-export declare function wrapQuery(name: string, args: Arg[], ast: DocumentNode): DocumentNode;