@takeshape/ssg 11.143.2 → 11.154.1

package/dist/graphql/ast.js

@@ -1,122 +0,0 @@
-import { Kind } from 'graphql/language';
-export function createArgument({ name, value }) {
-    return {
-        kind: Kind.ARGUMENT,
-        name: {
-            kind: Kind.NAME,
-            value: name
-        },
-        value: {
-            kind: Kind.VARIABLE,
-            name: {
-                kind: Kind.NAME,
-                value
-            }
-        }
-    };
-}
-function notNull(type) {
-    return {
-        kind: Kind.NON_NULL_TYPE,
-        type
-    };
-}
-function createType(typeString) {
-    const isNotNull = typeString.endsWith('!');
-    const value = isNotNull ? typeString.slice(0, typeString.length - 1) : typeString;
-    const namedType = {
-        kind: Kind.NAMED_TYPE,
-        name: {
-            kind: Kind.NAME,
-            value
-        }
-    };
-    return isNotNull ? notNull(namedType) : namedType;
-}
-export function createVariableDefinition({ name, type }) {
-    return {
-        kind: Kind.VARIABLE_DEFINITION,
-        directives: [],
-        variable: {
-            kind: Kind.VARIABLE,
-            name: {
-                kind: Kind.NAME,
-                value: name
-            }
-        },
-        type: createType(type)
-    };
-}
-export function createSelectionSet(selections) {
-    return {
-        kind: Kind.SELECTION_SET,
-        selections
-    };
-}
-export function createField(name) {
-    return {
-        kind: Kind.FIELD,
-        name: {
-            kind: Kind.NAME,
-            value: name
-        },
-        arguments: [],
-        directives: []
-    };
-}
-export function isQueryNode(node) {
-    return node.kind === 'OperationDefinition' && node.operation === 'query';
-}
-export function findQuery(ast) {
-    return ast.definitions.find(isQueryNode);
-}
-export function updateQuery(ast, update) {
-    const index = ast.definitions.findIndex(isQueryNode);
-    if (index !== -1) {
-        const { definitions, ...rest } = ast;
-        const updatedDefinitions = [...definitions];
-        updatedDefinitions[index] = update(definitions[index]);
-        return { ...rest, definitions: updatedDefinitions };
-    }
-    return ast;
-}
-export function addQueryVariables(variables, ast) {
-    return updateQuery(ast, (query) => {
-        const variableNames = new Set(variables.map((variable) => variable.name));
-        if (query.variableDefinitions) {
-            return {
-                ...query,
-                variableDefinitions: query.variableDefinitions
-                    .filter((def) => !variableNames.has(def.variable.name.value))
-                    .concat(variables.map(createVariableDefinition))
-            };
-        }
-        return query;
-    });
-}
-export function wrapSelectionSet(selectionSet, name, args = []) {
-    return {
-        kind: Kind.SELECTION_SET,
-        selections: [
-            {
-                kind: Kind.FIELD,
-                name: {
-                    kind: Kind.NAME,
-                    value: name
-                },
-                arguments: args,
-                directives: [],
-                selectionSet
-            }
-        ]
-    };
-}
-export function wrapQuery(name, args, ast) {
-    return updateQuery(ast, (query) => {
-        const argsAst = args.map(createArgument);
-        return {
-            ...query,
-            selectionSet: wrapSelectionSet(query.selectionSet, name, argsAst)
-        };
-    });
-}

package/dist/graphql/client-schema.d.ts

@@ -1,3 +0,0 @@
-import { type GraphQLSchema } from 'graphql';
-import type { GraphQLConnector } from '../types.ts';
-export declare function getClientSchema(connector: GraphQLConnector): Promise<GraphQLSchema>;

package/dist/graphql/client-schema.js

@@ -1,8 +0,0 @@
-import { buildClientSchema, getIntrospectionQuery } from 'graphql';
-export async function getClientSchema(connector) {
-    const res = await connector({ query: getIntrospectionQuery() }, { applyMigrations: false });
-    if (!res.data) {
-        throw new Error('Failed to fetch client schema');
-    }
-    return buildClientSchema(res.data);
-}

package/dist/graphql/index.d.ts

@@ -1,6 +0,0 @@
-export { getFieldUsage, getTypeUsage, type TypeUsage } from './analyze.ts';
-export { getClientSchema } from './client-schema.ts';
-export { connectorWithMigrations } from './migrate.ts';
-export { getQueryIterator } from './pagination.ts';
-export { withQueryTransforms } from './query.ts';
-export { schemaConnectorFactory } from './schema-connector-factory.ts';

package/dist/graphql/index.js

@@ -1,6 +0,0 @@
-export { getFieldUsage, getTypeUsage } from "./analyze.js";
-export { getClientSchema } from "./client-schema.js";
-export { connectorWithMigrations } from "./migrate.js";
-export { getQueryIterator } from "./pagination.js";
-export { withQueryTransforms } from "./query.js";
-export { schemaConnectorFactory } from "./schema-connector-factory.js";

package/dist/graphql/migrate.d.ts

@@ -1,19 +0,0 @@
-import { type DocumentNode } from 'graphql';
-import { type Location, type SourceLocation } from 'graphql/language';
-import type { GraphQLConnector, GraphQLResult } from '../types.ts';
-export declare function formatWarning(name: string, loc?: Location, queryStr?: string, source?: string): Warning;
-export type MapGraphQLResponse = (res: GraphQLResult) => GraphQLResult;
-export declare function getMapResponse(props: string[]): MapGraphQLResponse;
-export type Warning = {
-    message: string;
-    location: SourceLocation;
-    source: string;
-};
-export type MigrateListQueriesResult = {
-    ast: DocumentNode;
-    warnings: Warning[];
-    migrated: boolean;
-    mapResponse: MapGraphQLResponse | null;
-};
-export declare function migrateListQueries(ast: DocumentNode, queryStr?: string, source?: string): MigrateListQueriesResult;
-export declare function connectorWithMigrations(connector: GraphQLConnector): GraphQLConnector;

package/dist/graphql/migrate.js

@@ -1,111 +0,0 @@
-import { parse, Source } from 'graphql';
-import { getLocation, Kind, print } from 'graphql/language';
-import { updateQuery } from "./ast.js";
-function wrapListQuerySelection(selectionSet) {
-    return {
-        kind: Kind.SELECTION_SET,
-        selections: [
-            {
-                kind: Kind.FIELD,
-                name: {
-                    kind: Kind.NAME,
-                    value: 'items'
-                },
-                arguments: [],
-                directives: [],
-                selectionSet
-            },
-            {
-                kind: Kind.FIELD,
-                name: {
-                    kind: Kind.NAME,
-                    value: 'total'
-                },
-                arguments: [],
-                directives: []
-            }
-        ]
-    };
-}
-function isOldListQuery(selection) {
-    if (selection.kind !== 'Field') {
-        return false;
-    }
-    const { name, selectionSet } = selection;
-    return Boolean(/^get.+List$/.exec(name.value) &&
-        selectionSet &&
-        !selectionSet.selections.find((selection) => selection.kind === 'Field' && (selection.name.value === 'items' || selection.name.value === 'total')));
-}
-const startLocation = { line: 1, column: 1 };
-export function formatWarning(name, loc, queryStr, source) {
-    const location = queryStr && loc && source
-        ? getLocation(new Source(queryStr, source, startLocation), loc.start)
-        : { line: 1, column: 1 };
-    return {
-        message: `Using old format of ${name} Line ${location.line} Column ${location.column}`,
-        location,
-        source: source ?? ''
-    };
-}
-export function getMapResponse(props) {
-    return (res) => {
-        // Shallow clone res
-        const newRes = { ...res };
-        newRes.data = { ...res.data };
-        for (const prop of props) {
-            if (res.data?.[prop]) {
-                newRes.data[prop] = res.data[prop].items;
-            }
-        }
-        return newRes;
-    };
-}
-export function migrateListQueries(ast, queryStr, source) {
-    let migrated = false;
-    const migratedProps = [];
-    const warnings = [];
-    const updatedAst = updateQuery(ast, (queryDef) => {
-        return {
-            ...queryDef,
-            selectionSet: {
-                ...queryDef.selectionSet,
-                selections: queryDef.selectionSet.selections.map((selection) => {
-                    if (isOldListQuery(selection) && selection.selectionSet) {
-                        migratedProps.push(selection.alias ? selection.alias.value : selection.name.value);
-                        migrated = true;
-                        warnings.push(formatWarning(selection.name.value, selection.loc, queryStr, source));
-                        return {
-                            ...selection,
-                            selectionSet: wrapListQuerySelection(selection.selectionSet)
-                        };
-                    }
-                    return selection;
-                })
-            }
-        };
-    });
-    return {
-        ast: updatedAst,
-        warnings,
-        migrated,
-        mapResponse: migrated ? getMapResponse(migratedProps) : null
-    };
-}
-export function connectorWithMigrations(connector) {
-    return async (gqlParams, { stats, source = 'query.graphql', applyMigrations = true } = {}) => {
-        if (!applyMigrations) {
-            return connector(gqlParams);
-        }
-        let { query } = gqlParams;
-        const queryAst = parse(query);
-        const { migrated, warnings, ast, mapResponse } = migrateListQueries(queryAst, query, source);
-        if (migrated) {
-            query = print(ast);
-        }
-        if (warnings && stats?.warnings) {
-            stats.warnings = stats.warnings.concat(warnings);
-        }
-        const res = await connector({ query, variables: gqlParams.variables });
-        return migrated && mapResponse ? mapResponse(res) : res;
-    };
-}

package/dist/graphql/pagination.d.ts

@@ -1,36 +0,0 @@
-import { type DocumentNode, type GraphQLSchema } from 'graphql';
-import type { Data, GraphQLConnector, Stats } from '../types.ts';
-export type PaginationStrategy = {
-    type: string;
-    fromName: string;
-    sizeName: string;
-    hasNextPath?: string[];
-    cursorPath?: string[];
-    totalPath?: string[];
-    itemsPath: string[];
-};
-export type PaginatedField = {
-    strategy: PaginationStrategy;
-    fromVarName: string;
-    sizeVarName: string;
-    astPath: string[];
-    queryPath: string[];
-};
-export declare function findPaginatedFields(ast: DocumentNode, schema: GraphQLSchema): PaginatedField[];
-export declare function removeNonPaginated(ast: DocumentNode, paginatedFields: PaginatedField[]): DocumentNode;
-export declare function addPaginationVariables(ast: DocumentNode, paginatedFields: PaginatedField[]): DocumentNode;
-export declare function hasField(ast: Record<string, any>, queryPath: string[]): boolean;
-export declare function ensureField(ast: any, queryPath: string[]): DocumentNode;
-export declare function ensurePaginationFields(ast: DocumentNode, paginatedFields: PaginatedField[], source?: string): DocumentNode;
-export declare function isDone(queryArgs: Data, queryData: Data, paginatedField: PaginatedField): boolean;
-export type GetQueryIteratorOptions = {
-    variables?: Data;
-    pageSize?: number;
-    source?: string;
-    stats?: Stats;
-};
-export type QueryIteratorResult = {
-    iterator: () => AsyncGenerator;
-    total?: number;
-};
-export declare function getQueryIterator(schema: GraphQLSchema, query: string, connector: GraphQLConnector, { variables, pageSize, source, stats }?: GetQueryIteratorOptions): Promise<QueryIteratorResult>;

package/dist/graphql/pagination.js

@@ -1,268 +0,0 @@
-import { parse, print, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
-import get from 'lodash/get.js';
-import keyBy from 'lodash/keyBy.js';
-import GraphQLError from "../errors/graphql-error.js";
-import PaginationError from "../errors/pagination-error.js";
-import { updateIn } from "../util.js";
-import { createArgument, createField, createSelectionSet, createVariableDefinition } from "./ast.js";
-const paginationStrategies = [
-    {
-        type: 'cursor',
-        fromName: 'after',
-        sizeName: 'first',
-        hasNextPath: ['pageInfo', 'hasNextPage'],
-        cursorPath: ['pageInfo', 'endCursor'],
-        itemsPath: ['items']
-    },
-    {
-        type: 'offset',
-        fromName: 'from',
-        sizeName: 'size',
-        totalPath: ['total'],
-        itemsPath: ['items']
-    },
-    {
-        type: 'offset',
-        fromName: 'offset',
-        sizeName: 'limit',
-        totalPath: ['total'],
-        itemsPath: ['items']
-    }
-];
-function getPaginationStrategy(fieldDef) {
-    if (fieldDef) {
-        const { args } = fieldDef;
-        if (args?.length) {
-            const keyedArgs = keyBy(args, 'name');
-            return paginationStrategies.find((strategy) => {
-                const { fromName, sizeName } = strategy;
-                return keyedArgs[fromName] && keyedArgs[sizeName];
-            });
-        }
-    }
-}
-function getVariableName(path, name) {
-    return path.concat([name]).join('_');
-}
-export function findPaginatedFields(ast, schema) {
-    const typeInfo = new TypeInfo(schema);
-    const result = [];
-    const queryPath = [];
-    const visitor = {
-        Field: {
-            enter(node, _, __, path) {
-                queryPath.push(node.alias ? node.alias.value : node.name.value);
-                const fieldDef = typeInfo.getFieldDef();
-                if (fieldDef) {
-                    const strategy = getPaginationStrategy(fieldDef);
-                    if (strategy) {
-                        result.push({
-                            strategy,
-                            fromVarName: getVariableName(queryPath, strategy.fromName),
-                            sizeVarName: getVariableName(queryPath, strategy.sizeName),
-                            astPath: path.map(String),
-                            queryPath: queryPath.slice()
-                        });
-                        // Skip child nodes
-                        queryPath.pop();
-                        return false;
-                    }
-                }
-            },
-            leave() {
-                queryPath.pop();
-            }
-        }
-    };
-    visit(ast, visitWithTypeInfo(typeInfo, visitor));
-    return result;
-}
-export function removeNonPaginated(ast, paginatedFields) {
-    const paths = new Set();
-    for (const field of paginatedFields) {
-        paths.add(field.astPath.join('.'));
-    }
-    const visitor = {
-        Field: {
-            enter(_, __, ___, path) {
-                return paths.has(path.join('.')) ? false : null;
-            }
-        }
-    };
-    return visit(ast, visitor);
-}
-export function addPaginationVariables(ast, paginatedFields) {
-    const variablesToReplace = Object.create(null);
-    const variables = [];
-    for (const paginatedField of paginatedFields) {
-        const { fromVarName, sizeVarName, strategy } = paginatedField;
-        const { sizeName, fromName } = strategy;
-        updateIn(ast, paginatedField.astPath, (field) => {
-            let args;
-            if (field.arguments) {
-                args = field.arguments.filter((arg) => {
-                    const name = arg.name.value;
-                    if (name === sizeName || name === fromName) {
-                        if (arg.value.kind === 'Variable') {
-                            variablesToReplace[arg.value.name.value] = true;
-                        }
-                        return false;
-                    }
-                    return true;
-                });
-                args.push(createArgument({ name: fromName, value: fromVarName }));
-                args.push(createArgument({ name: sizeName, value: sizeVarName }));
-            }
-            variables.push({
-                name: fromVarName,
-                type: paginatedField.strategy.type === 'cursor' ? 'String' : 'Int'
-            });
-            variables.push({ name: sizeVarName, type: 'Int' });
-            return args ? { ...field, arguments: args } : field;
-        });
-    }
-    const queryPath = paginatedFields[0].astPath.slice(0, 2);
-    updateIn(ast, queryPath, (query) => {
-        if (query.variableDefinitions) {
-            return {
-                ...query,
-                variableDefinitions: query.variableDefinitions
-                    .filter((def) => !variablesToReplace[def.variable.name.value])
-                    .concat(variables.map(createVariableDefinition))
-            };
-        }
-        return query;
-    });
-    return ast;
-}
-export function hasField(ast, queryPath) {
-    let node = ast;
-    for (const name of queryPath) {
-        if (!node.selectionSet) {
-            return false;
-        }
-        const field = node.selectionSet.selections.find((selection) => selection.kind === 'Field' && selection.name.value === name);
-        if (field) {
-            node = field;
-        }
-        else {
-            return false;
-        }
-    }
-    return true;
-}
-export function ensureField(ast, queryPath) {
-    let node = ast;
-    for (const name of queryPath) {
-        if (node.selectionSet) {
-            let { selections } = node.selectionSet;
-            const field = selections.find((selection) => selection.kind === 'Field' && selection.name.value === name);
-            if (field) {
-                node = field;
-            }
-            else {
-                selections = selections.concat([createField(name)]);
-                node.selectionSet.selections = selections;
-                node = selections[selections.length - 1];
-            }
-        }
-        else {
-            node.selectionSet = createSelectionSet([createField(name)]);
-            node = node.selectionSet.selections[0];
-        }
-    }
-    return ast;
-}
-export function ensurePaginationFields(ast, paginatedFields, source = '') {
-    for (const paginatedField of paginatedFields) {
-        const { strategy, astPath, queryPath } = paginatedField;
-        const { type } = strategy;
-        const field = get(ast, astPath);
-        if (!hasField(field, strategy.itemsPath)) {
-            const missingPath = queryPath.concat(strategy.itemsPath).join('.');
-            throw new PaginationError(`Expected ${missingPath} to be specified: ${source}`);
-        }
-        if (type === 'cursor' && strategy.hasNextPath && strategy.cursorPath) {
-            ensureField(field, strategy.hasNextPath);
-            ensureField(field, strategy.cursorPath);
-        }
-        else if (strategy.totalPath) {
-            ensureField(field, strategy.totalPath);
-        }
-    }
-    return ast;
-}
-export function isDone(queryArgs, queryData, paginatedField) {
-    const { strategy, queryPath, fromVarName, sizeVarName } = paginatedField;
-    const { hasNextPath, totalPath } = strategy;
-    if (hasNextPath) {
-        return !get(queryData, queryPath.concat(hasNextPath));
-    }
-    if (totalPath) {
-        return queryArgs[fromVarName] + queryArgs[sizeVarName] >= get(queryData, queryPath.concat(totalPath));
-    }
-    throw Error('Invalid pagination strategy');
-}
-function incrementVariables(variables, data, paginatedField) {
-    const { strategy, queryPath, fromVarName, sizeVarName } = paginatedField;
-    const { cursorPath, type } = strategy;
-    if (type === 'cursor' && cursorPath) {
-        variables[fromVarName] = get(data, queryPath.concat(cursorPath));
-    }
-    else {
-        variables[fromVarName] += variables[sizeVarName];
-    }
-}
-function handleErrors(res, source) {
-    if (res.errors) {
-        throw new GraphQLError(`An error occurred ${source ?? 'unknown source'}`, res.errors);
-    }
-}
-export async function getQueryIterator(schema, query, connector, { variables, pageSize = 100, source, stats } = {}) {
-    const queryAst = parse(query);
-    const paginatedFields = findPaginatedFields(queryAst, schema);
-    if (paginatedFields.length !== 1) {
-        throw new PaginationError(`No paginated fields: ${source ?? 'unknown source'}`);
-    }
-    const astWithVars = addPaginationVariables(queryAst, paginatedFields);
-    const astNormalized = ensurePaginationFields(astWithVars, paginatedFields, source);
-    const queryWithVars = print(astNormalized);
-    const vars = { ...variables };
-    // Initialize pagination vars
-    const paginatedField = paginatedFields[0];
-    if (paginatedField.strategy.type === 'offset') {
-        vars[paginatedField.fromVarName] = 0;
-    }
-    vars[paginatedField.sizeVarName] = pageSize;
-    const itemsPath = paginatedField.queryPath.concat(paginatedField.strategy.itemsPath);
-    let total;
-    let first;
-    const connectorContext = {
-        source,
-        stats,
-        applyMigrations: false,
-        isPaginated: true
-    };
-    if (paginatedField.strategy.type === 'offset' && paginatedField.strategy.totalPath) {
-        const totalPath = paginatedField.queryPath.concat(paginatedField.strategy.totalPath);
-        first = await connector({ query: queryWithVars, variables: vars }, connectorContext);
-        handleErrors(first, source);
-        total = get(first.data, totalPath);
-    }
-    const iterator = async function* () {
-        while (true) {
-            const res = first ?? (await connector({ query: queryWithVars, variables: vars }, connectorContext));
-            first &&= null;
-            handleErrors(res, source);
-            const data = res.data;
-            for (const item of get(data, itemsPath).filter(Boolean)) {
-                yield item;
-            }
-            if (isDone(vars, data, paginatedField)) {
-                break;
-            }
-            incrementVariables(vars, data, paginatedField);
-        }
-    };
-    return { total, iterator };
-}

package/dist/graphql/query.d.ts

@@ -1,20 +0,0 @@
-import type { GraphQLFieldMap } from 'graphql';
-import { type DocumentNode, type GraphQLOutputType, type GraphQLSchema } from 'graphql';
-import type { GraphQLConnector } from '../types.ts';
-export declare function getItemType(fieldType: GraphQLOutputType): GraphQLOutputType;
-export declare function getFields(type: GraphQLOutputType): GraphQLFieldMap<any, any> | undefined;
-export declare function ensureIds(queryAst: DocumentNode, schema: GraphQLSchema): DocumentNode;
-export declare function wrapWithLocaleContext(ast: DocumentNode): DocumentNode;
-export declare const FILTER_VAR_NAME = "__filter";
-export type AddContentIdFilterResult = {
-    ast: DocumentNode;
-    varName: string;
-    modified: boolean;
-};
-export declare function addContentIdFilter(ast: DocumentNode, schema: GraphQLSchema): AddContentIdFilterResult;
-export type WithQueryTransformsParams = {
-    locale?: string;
-    usage?: boolean;
-    contentId?: string;
-};
-export declare function withQueryTransforms(connector: GraphQLConnector, schema: GraphQLSchema, { locale, usage, contentId }?: WithQueryTransformsParams): GraphQLConnector;