@takeshape/schema 11.143.2 → 11.154.1

package/dist/taxonomies.d.ts

@@ -1,15 +0,0 @@
-import type { ProjectSchemaJSON, ShapeJSON } from './project-schema/index.ts';
-export type TaxonomyField = {
-    name: string;
-    key?: string;
-};
-export type Taxonomy = {
-    shapeId: string;
-    field: TaxonomyField;
-};
-export declare function getFirstStringFieldV3(shape: ShapeJSON, projectSchema: ProjectSchemaJSON): {
-    name: string;
-    key?: string;
-} | null;
-export declare const getTaxonomyField: (shape: ShapeJSON, projectSchema: ProjectSchemaJSON) => TaxonomyField | null;
-export declare const getTaxonomies: (projectSchema: ProjectSchemaJSON) => Taxonomy[];

package/dist/taxonomies.js

@@ -1,24 +0,0 @@
-import { weakMemoize } from '@takeshape/util';
-import { createSchemaPropertyAccessor } from "./schema-util.js";
-export function getFirstStringFieldV3(shape, projectSchema) {
-    const forms = projectSchema.forms?.[shape.name];
-    if (!forms?.default) {
-        return null;
-    }
-    const schemaProperties = createSchemaPropertyAccessor(projectSchema, shape);
-    const { order } = forms.default;
-    const name = order.find((name) => schemaProperties.getValue(name)?.type === 'string');
-    return name ? { name, key: schemaProperties.getKey(name) } : null;
-}
-export const getTaxonomyField = weakMemoize((shape, projectSchema) => shape.model?.type === 'taxonomy' ? getFirstStringFieldV3(shape, projectSchema) : null);
-export const getTaxonomies = weakMemoize((projectSchema) => {
-    const { shapes } = projectSchema;
-    return Object.keys(shapes).reduce((result, shapeName) => {
-        const shape = shapes[shapeName];
-        const field = getTaxonomyField(shape, projectSchema);
-        if (field) {
-            result.push({ shapeId: shape.id, field });
-        }
-        return result;
-    }, []);
-});

package/dist/template-shapes/index.d.ts

@@ -1,7 +0,0 @@
-import type { ProjectSchemaJSON } from '../project-schema/index.ts';
-import type { ResolvedTemplate } from './types.ts';
-export declare function resolveTemplate(projectSchema: ProjectSchemaJSON, templateName: string, shapeName: string): ResolvedTemplate;
-/**
- * Check if a string is a known template such as `PaginatedList`
- */
-export declare function isValidTemplate(template: string): boolean;

package/dist/template-shapes/index.js

@@ -1,33 +0,0 @@
-import { CreateArgs, CreateResult, DeleteArgs, DeleteResult, DuplicateArgs, DuplicateResult, PaginatedList, SearchResults, TSGetArgs, TSGetSingletonArgs, TSListArgs, TSSearchArgs, UpdateArgs, UpdateResult } from "./templates.js";
-const templateMappings = {
-    TSGetArgs,
-    TSGetSingletonArgs,
-    TSListArgs,
-    TSSearchArgs,
-    CreateArgs,
-    UpdateArgs,
-    DuplicateArgs,
-    DeleteArgs,
-    PaginatedList,
-    SearchResults,
-    CreateResult,
-    UpdateResult,
-    DuplicateResult,
-    DeleteResult
-};
-export function resolveTemplate(projectSchema, templateName, shapeName) {
-    const mapping = templateMappings[templateName];
-    if (!mapping) {
-        throw new Error(`Invalid shape template ${templateName}`);
-    }
-    if (projectSchema.shapes[shapeName] === undefined) {
-        throw new Error(`Unknown shape "${shapeName}" in template "${templateName}"`);
-    }
-    return mapping({ projectSchema }, projectSchema.shapes[shapeName]);
-}
-/**
- * Check if a string is a known template such as `PaginatedList`
- */
-export function isValidTemplate(template) {
-    return Boolean(templateMappings[template]);
-}

package/dist/template-shapes/names.d.ts

@@ -1,10 +0,0 @@
-import type { TemplateVerbs } from './types.ts';
-/**
- * Construct a shape name used for a mutation input shape.
- */
-export declare function getMutationInputShapeName(verb: TemplateVerbs): (shapeName: string) => string;
-/**
- * Create a shape name variant for an input.
- */
-export declare function getInputShapeName(shapeName: string): string;
-export declare function getOutputShapeName(name: string): string;

package/dist/template-shapes/names.js

@@ -1,21 +0,0 @@
-import { formatShapeName } from '@takeshape/util';
-/**
- * Construct a shape name used for a mutation input shape.
- */
-export function getMutationInputShapeName(verb) {
-    return (shapeName) => {
-        return formatShapeName([verb, shapeName, 'input'], { shapeNameIndex: 1 });
-    };
-}
-/**
- * Create a shape name variant for an input.
- */
-export function getInputShapeName(shapeName) {
-    if (shapeName === 'TSRelationship') {
-        return shapeName;
-    }
-    return `${shapeName}Input`;
-}
-export function getOutputShapeName(name) {
-    return name.replace(/(?:Input|PartialInput)$/, '');
-}

package/dist/template-shapes/templates.d.ts

@@ -1,32 +0,0 @@
-import type { ObjectSchema, PropertySchema, ShapeJSON } from '../project-schema/index.ts';
-import type { ResolvedTemplate, TemplateContext } from './types.ts';
-import { TemplateVerbs } from './types.ts';
-export declare const TSGetArgs: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const TSGetSingletonArgs: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const TSListArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare const TSSearchArgs: (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare const CreateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare const UpdateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare const DuplicateArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare const DeleteArgs: ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare const PaginatedList: typeof getPaginatedListShape;
-export declare const SearchResults: typeof getSearchResultsShape;
-export declare const CreateResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const UpdateResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const DuplicateResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const DeleteResult: (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const TSSearchSortInput: ShapeJSON;
-export declare const commonSearchProps: Record<string, PropertySchema>;
-export declare const localeProps: ObjectSchema;
-export declare const termsProps: ObjectSchema;
-export declare const TSContentStructureInput: ShapeJSON;
-export declare function getPaginatedListShape(_context: unknown, shape: ShapeJSON): ResolvedTemplate;
-export declare function getSearchResultsShape(_context: unknown, shape: ShapeJSON): ResolvedTemplate;
-export declare function getIDQueryArgs(templateName: string): (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-/**
- * Construct shapes for a mutation inputs, given source shape info.
- */
-export declare function getMutationArgs(templateName: string, verb: TemplateVerbs): ({ projectSchema }: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare function getMutationResultType(verb: TemplateVerbs): (_context: unknown, shape: ShapeJSON) => ResolvedTemplate;
-export declare const commonSearchArgs: ObjectSchema;
-export declare function getShapeListQueryArgs(templateName: string, legacyArgs: boolean): (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;

package/dist/template-shapes/templates.js

@@ -1,316 +0,0 @@
-import { deepClone, formatShapeName, isDefined, visit } from '@takeshape/util';
-import get from 'lodash/get.js';
-import keyBy from 'lodash/keyBy.js';
-import { createInputSchema } from "../create-input-schema.js";
-import { listTypePrefix } from "../migration/index.js";
-import { getFlattenedTemplateShapeName, getRef, getRefShapeName, serializeRef } from "../refs.js";
-import { createShape, getShapeDependencies } from "../schema-util.js";
-import { isCachedShape } from "../types/index.js";
-import { mergeObjectSchemas, mergeSchemaProperties } from "../util/merge.js";
-import { getInputShapeName, getMutationInputShapeName } from "./names.js";
-import { TemplateVerbs } from "./types.js";
-import { getWhereSearchArg } from "./where.js";
-export const TSGetArgs = getIDQueryArgs('TSGetArgs');
-export const TSGetSingletonArgs = getIDQueryArgs('TSGetSingletonArgs');
-export const TSListArgs = getShapeListQueryArgs('TSListArgs', true);
-export const TSSearchArgs = getShapeListQueryArgs('TSSearchArgs', false);
-export const CreateArgs = getMutationArgs('CreateArgs', TemplateVerbs.Create);
-export const UpdateArgs = getMutationArgs('UpdateArgs', TemplateVerbs.Update);
-export const DuplicateArgs = getMutationArgs('DuplicateArgs', TemplateVerbs.Duplicate);
-export const DeleteArgs = getMutationArgs('DeleteArgs', TemplateVerbs.Delete);
-export const PaginatedList = getPaginatedListShape;
-export const SearchResults = getSearchResultsShape;
-export const CreateResult = getMutationResultType(TemplateVerbs.Create);
-export const UpdateResult = getMutationResultType(TemplateVerbs.Update);
-export const DuplicateResult = getMutationResultType(TemplateVerbs.Duplicate);
-export const DeleteResult = getMutationResultType(TemplateVerbs.Delete);
-export const TSSearchSortInput = createShape('TSSearchSortInput', {
-    type: 'object',
-    properties: {
-        field: { type: 'string' },
-        order: {
-            type: 'string',
-            description: '"asc" for ascending or "desc" for descending'
-        }
-    },
-    required: ['field', 'order']
-});
-export const commonSearchProps = {
-    terms: { type: 'string' },
-    from: {
-        type: 'integer',
-        description: 'The offset from the first result you want to fetch.'
-    },
-    size: {
-        type: 'integer',
-        description: 'The maximum number of items to return.'
-    },
-    filter: {
-        type: 'object',
-        description: 'An elasticsearch style filter. Overrides onlyEnabled.'
-    },
-    sort: {
-        type: 'array',
-        description: 'An list of fields to sort by.',
-        items: {
-            '@ref': `local:${TSSearchSortInput.name}`
-        }
-    }
-};
-export const localeProps = {
-    type: 'object',
-    properties: {
-        locale: { type: 'string' },
-        enableLocaleFallback: { type: 'boolean', default: true }
-    }
-};
-export const termsProps = {
-    type: 'object',
-    properties: {
-        terms: { type: 'string' }
-    }
-};
-export const TSContentStructureInput = createShape('TSContentStructureInput', {
-    type: 'object',
-    properties: {
-        path: {
-            type: 'string',
-            description: 'A deep path to the array being updated (e.g. a.b[1].c).'
-        },
-        structure: {
-            type: 'array',
-            description: 'An array where the indices represent the to index, and the values represent the from index.' +
-                'For example to transform ["a","b","c","d"] into ["c","a"], this value would be [2,0].',
-            items: {
-                type: 'integer'
-            }
-        }
-    },
-    required: ['path']
-}, { description: 'Describes a structural update to an array of data.' });
-export function getPaginatedListShape(_context, shape) {
-    const shapeName = `${shape.name}${listTypePrefix}`;
-    return {
-        shapeName,
-        dependencies: {
-            [shapeName]: createShape(shapeName, {
-                type: 'object',
-                properties: {
-                    items: { type: 'array', items: { '@ref': `local:${shape.name}` } },
-                    total: { type: 'integer' }
-                },
-                required: ['items', 'total']
-            })
-        }
-    };
-}
-export function getSearchResultsShape(_context, shape) {
-    const shapeName = `${shape.name}SearchResults`;
-    return {
-        shapeName,
-        dependencies: {
-            [shapeName]: createShape(shapeName, {
-                type: 'object',
-                properties: {
-                    results: {
-                        type: 'array',
-                        items: { '@ref': `local:${shape.name}` }
-                    },
-                    total: { type: 'integer' }
-                },
-                required: ['results', 'total']
-            }, { description: `${shape.name} search results` })
-        }
-    };
-}
-const contentStructureFields = {
-    type: 'object',
-    properties: {
-        structure: {
-            type: 'array',
-            items: {
-                '@ref': 'local:TSContentStructureInput'
-            }
-        }
-    }
-};
-const idSchema = {
-    type: 'object',
-    properties: {
-        _id: { type: 'string' }
-    },
-    required: ['_id']
-};
-export function getIDQueryArgs(templateName) {
-    return (_context, shape) => {
-        const schema = shape.model?.type !== 'single' ? mergeSchemaProperties(idSchema, localeProps) : localeProps;
-        const shapeName = getFlattenedTemplateShapeName(shape.name, templateName);
-        return {
-            shapeName,
-            dependencies: {
-                [shapeName]: createShape(shapeName, schema)
-            }
-        };
-    };
-}
-function rewriteRefs(context, shapeSchema, rewriteShapeName) {
-    const newSchema = deepClone(shapeSchema);
-    visit(newSchema, ['$ref', '@ref'], (_, path) => {
-        const parentPath = path.slice(0, -1);
-        const value = get(newSchema, parentPath);
-        if ((value['@ref'] || value.$ref) && !parentPath.includes('@input') && !parentPath.includes('@output')) {
-            const refItem = getRef(context, value);
-            if (refItem) {
-                value['@ref'] = serializeRef(refItem.layerId === 'local' ? { ...refItem, shapeName: rewriteShapeName(refItem.shapeName) } : refItem);
-                if (value.$ref) {
-                    delete value.$ref;
-                }
-            }
-        }
-    });
-    return newSchema;
-}
-/**
- * Construct shapes for a mutation inputs, given source shape info.
- */
-export function getMutationArgs(templateName, verb) {
-    const getShapeName = getMutationInputShapeName(verb);
-    const addLocale = verb === TemplateVerbs.Update || verb === TemplateVerbs.Duplicate;
-    const addStructure = verb === TemplateVerbs.Update;
-    const isUpdate = verb === TemplateVerbs.Update || verb === TemplateVerbs.Duplicate;
-    return ({ projectSchema }, shape) => {
-        const inputName = getShapeName(shape.name);
-        const isSingleton = shape.model && shape.model.type === 'single';
-        const shouldRequireId = !isSingleton &&
-            (verb === TemplateVerbs.Update || verb === TemplateVerbs.Delete || verb === TemplateVerbs.Duplicate);
-        let rewrittenSchema;
-        let inputShapeSchema;
-        if (verb !== TemplateVerbs.Delete) {
-            rewrittenSchema = createInputSchema(shape.schema, { isUpdate });
-            inputShapeSchema = rewriteRefs(projectSchema, rewrittenSchema, getInputShapeName);
-        }
-        const inputShape = createShape(inputName, mergeObjectSchemas(shouldRequireId ? idSchema : undefined, inputShapeSchema), { description: `${verb} ${shape.name} input` });
-        const argsShapeName = getFlattenedTemplateShapeName(shape.name, templateName);
-        const argsShape = createShape(argsShapeName, mergeObjectSchemas({
-            type: 'object',
-            properties: {
-                input: { '@ref': `local:${inputShape.name}` },
-                clientMutationId: { type: 'string' }
-            },
-            required: ['input']
-        }, addStructure ? contentStructureFields : undefined, addLocale ? localeProps : undefined));
-        return {
-            shapeName: argsShapeName,
-            dependencies: {
-                [inputName]: inputShape,
-                [argsShapeName]: argsShape,
-                ...(verb !== TemplateVerbs.Delete &&
-                    keyBy(getShapeDependencies(projectSchema, 
-                    // get the shape dependencies of the shape with the @input swapped
-                    createShape(inputShape.name, rewrittenSchema), (propSchema) => {
-                        if (propSchema['@resolver']) {
-                            return false;
-                        }
-                        const shapeName = getRefShapeName(projectSchema, propSchema);
-                        if (shapeName) {
-                            return shapeName !== 'TSRelationship' && !projectSchema.shapes[getInputShapeName(shapeName)];
-                        }
-                        return true;
-                    })
-                        .map((shapeName) => {
-                        const shape = projectSchema.shapes[shapeName];
-                        if (!shape) {
-                            return;
-                        }
-                        // We only allow partial input at the top-level
-                        return createShape(getInputShapeName(shapeName), rewriteRefs(projectSchema, createInputSchema(shape.schema), getInputShapeName));
-                    })
-                        .filter(isDefined), 'name')),
-                ...(addStructure ? { TSContentStructureInput } : {})
-            }
-        };
-    };
-}
-export function getMutationResultType(verb) {
-    return (_context, shape) => {
-        const shapeName = formatShapeName([verb, shape.name, 'result'], {
-            shapeNameIndex: 1
-        });
-        const result = verb === TemplateVerbs.Delete ? { type: 'boolean' } : { '@ref': `local:${shape.name}` };
-        return {
-            shapeName,
-            dependencies: {
-                [shapeName]: createShape(shapeName, {
-                    type: 'object',
-                    properties: {
-                        clientMutationId: { type: 'string' },
-                        result
-                    }
-                })
-            }
-        };
-    };
-}
-export const commonSearchArgs = {
-    type: 'object',
-    properties: {
-        terms: { type: 'string' },
-        from: {
-            type: 'integer',
-            description: 'The offset from the first result you want to fetch.'
-        },
-        size: {
-            type: 'integer',
-            description: 'The maximum number of items to return.'
-        },
-        filter: {
-            type: 'object',
-            description: 'An elasticsearch style filter. Overrides onlyEnabled.'
-        },
-        sort: {
-            type: 'array',
-            description: 'An list of fields to sort by.',
-            items: {
-                '@ref': `local:${TSSearchSortInput.name}`
-            }
-        }
-    }
-};
-const legacyListArgs = {
-    type: 'object',
-    properties: {
-        onlyEnabled: {
-            type: 'boolean',
-            default: true,
-            description: 'Filter out content that is not enabled. Defaults to true.'
-        }
-    }
-};
-const shapeFilterProps = {
-    type: 'object',
-    properties: {
-        shapeNames: { type: 'array', items: { type: 'string' } },
-        shapeIds: { type: 'array', items: { type: 'string' } },
-        contentTypeNames: { type: 'array', items: { type: 'string' } },
-        contentTypeIds: { type: 'array', items: { type: 'string' } }
-    }
-};
-export function getShapeListQueryArgs(templateName, legacyArgs) {
-    return (context, shape) => {
-        const { projectSchema } = context;
-        const isAllShapes = shape.name === 'TSSearchable';
-        const shapeName = isAllShapes ? templateName : getFlattenedTemplateShapeName(shape.name, templateName);
-        const shapes = isAllShapes
-            ? Object.values(projectSchema.shapes).filter((s) => s.model !== undefined || isCachedShape(s))
-            : [shape];
-        const { schema, dependencies } = getWhereSearchArg(projectSchema, shapes);
-        return {
-            shapeName,
-            dependencies: {
-                ...dependencies,
-                TSSearchSortInput,
-                [shapeName]: createShape(shapeName, mergeObjectSchemas(commonSearchArgs, localeProps, legacyArgs ? legacyListArgs : undefined, isAllShapes ? shapeFilterProps : undefined, schema))
-            }
-        };
-    };
-}

package/dist/template-shapes/types.d.ts

@@ -1,15 +0,0 @@
-import type { ProjectSchemaJSON, ShapeJSON, ShapeMap } from '../project-schema/index.ts';
-export type ResolvedTemplate = {
-    shapeName: string;
-    dependencies: ShapeMap;
-};
-export type TemplateContext = {
-    projectSchema: ProjectSchemaJSON;
-};
-export type TemplateShapeFactory = (context: TemplateContext, shape: ShapeJSON) => ResolvedTemplate;
-export declare enum TemplateVerbs {
-    Create = "create",
-    Update = "update",
-    Duplicate = "duplicate",
-    Delete = "delete"
-}

package/dist/template-shapes/types.js

@@ -1,7 +0,0 @@
-export var TemplateVerbs;
-(function (TemplateVerbs) {
-    TemplateVerbs["Create"] = "create";
-    TemplateVerbs["Update"] = "update";
-    TemplateVerbs["Duplicate"] = "duplicate";
-    TemplateVerbs["Delete"] = "delete";
-})(TemplateVerbs || (TemplateVerbs = {}));

package/dist/template-shapes/where.d.ts

@@ -1,37 +0,0 @@
-import type { Maybe } from '@takeshape/util';
-import type { ObjectSchema, ProjectSchemaJSON, PropertySchema, ShapeJSON, ShapeMap } from '../project-schema/index.ts';
-import type { ResolvedTemplate } from './types.ts';
-export declare const MAX_RELATIONSHIP_DEPTH = 1;
-export declare const exceededRelationshipDepth: (depth?: number) => boolean;
-type ComparisonOperatorKey = 'eq' | 'lt' | 'lte' | 'gt' | 'gte' | 'in' | 'match' | 'regexp';
-type ShapeThunk = ShapeJSON | (() => ShapeJSON);
-declare class ShapeCache {
-    thunks: Map<string, ShapeThunk>;
-    unresolved: Set<string>;
-    has(shapeName: string): boolean;
-    set(shapeName: string, thunk: ShapeThunk): void;
-    resolveAll(): ShapeMap;
-}
-export declare const fieldTypeComparison: Record<string, {
-    comparators: ComparisonOperatorKey[];
-    type: 'string' | 'number' | 'integer' | 'boolean';
-}>;
-export declare const comparatorDescriptions: Record<string, string>;
-export declare const booleanOperators: string[];
-export declare const boolOpDescriptionMap: Record<string, string>;
-export declare function getFieldTypeComparison(fieldType: string): Maybe<Record<string, PropertySchema>>;
-export type PropertyContext = {
-    shapeCache: ShapeCache;
-    conflictingProperties?: Set<string>;
-    projectSchema: ProjectSchemaJSON;
-    relationshipDepth: number;
-    booleanOperators?: boolean;
-};
-export declare function getFields(typeName: string, shapes: ShapeJSON[], context: PropertyContext): Record<string, PropertySchema>;
-export declare function getPropertyComparisonType(name: string, prop: PropertySchema, shapeName: string, context: PropertyContext): Maybe<Record<string, PropertySchema>>;
-export declare function getWhereShape(projectSchema: ProjectSchemaJSON, selectedShapes: ShapeJSON[]): ResolvedTemplate;
-export declare function getWhereSearchArg(projectSchema: ProjectSchemaJSON, selectedShapes: ShapeJSON[]): {
-    schema: ObjectSchema;
-    dependencies: ShapeMap;
-};
-export {};