@webiny/api-headless-cms-storage 6.6.0-alpha.0 → 6.6.0-alpha.1

package/src/features/fieldSorting/abstractions.ts

@@ -1,49 +0,0 @@
-import { Abstraction } from "@webiny/di";
-import type { Field } from "../../filtering/fields/types.js";
-import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
-
-export interface IFieldSortingCanUseParams {
-    model: CmsModel;
-    field?: Field;
-    fieldId: string;
-    order: "ASC" | "DESC";
-    sortBy: string;
-}
-
-export interface IFieldSortingCreateParams {
-    model: CmsModel;
-    fieldId: string;
-    order: "ASC" | "DESC";
-    sortBy: string;
-    fields: Record<string, Field>;
-    field?: Field;
-}
-
-export interface IFieldSortingResult {
-    valuePath: string;
-    reverse: boolean;
-    fieldId: string;
-    field: Field;
-}
-
-export interface IFieldSortingHandler {
-    canUse(params: IFieldSortingCanUseParams): boolean;
-    createSort(params: IFieldSortingCreateParams): IFieldSortingResult;
-}
-
-export interface IFieldSortingRegistry {
-    register(handler: IFieldSortingHandler): void;
-    find(params: IFieldSortingCanUseParams): IFieldSortingHandler | undefined;
-}
-
-export const FieldSortingRegistry = new Abstraction<IFieldSortingRegistry>(
-    "Cms/Storage/FieldSortingRegistry"
-);
-
-export namespace FieldSortingRegistry {
-    export type Interface = IFieldSortingRegistry;
-    export type Handler = IFieldSortingHandler;
-    export type CanUseParams = IFieldSortingCanUseParams;
-    export type CreateParams = IFieldSortingCreateParams;
-    export type Result = IFieldSortingResult;
-}

package/src/filtering/expressions/createExpressions.ts

@@ -1,170 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { CmsEntryListWhere } from "@webiny/api-headless-cms/types/index.js";
-import type { Field } from "../fields/types.js";
-import { extractWhereParams } from "../where.js";
-import { transformValue } from "../transform.js";
-import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-import { ValueFilter, ValueFilterRegistry } from "@webiny/db-utils";
-import type { FieldFilterCreateRegistry } from "../../features/fieldFilterCreate/abstractions.js";
-import type { FieldFilterValueTransformRegistry } from "../../features/fieldFilterValueTransform/abstractions.js";
-import { getWhereValues } from "../values.js";
-
-interface CreateExpressionParams {
-    where: Partial<CmsEntryListWhere>;
-    condition: ExpressionCondition;
-}
-
-interface ICreateExpressionsParams {
-    filterCreateRegistry: FieldFilterCreateRegistry.Interface;
-    transformRegistry: FieldFilterValueTransformRegistry.Interface;
-    valueFilterRegistry: ValueFilterRegistry.Interface;
-    where: Partial<CmsEntryListWhere>;
-    fields: Record<string, Field>;
-}
-
-export type ExpressionCondition = "AND" | "OR";
-
-export interface Expression {
-    expressions: Expression[];
-    filters: Filter[];
-    condition: ExpressionCondition;
-}
-
-export interface Filter {
-    field: Field;
-    path: string;
-    fieldPathId: string;
-    filter: ValueFilter.Interface;
-    negate: boolean;
-    compareValue: any;
-    transformValue: <I = any, O = any>(value: I) => O;
-}
-
-export const createExpressions = (params: ICreateExpressionsParams): Expression => {
-    const { where, filterCreateRegistry, transformRegistry, fields, valueFilterRegistry } = params;
-
-    const getHandler = (type: string) => {
-        const fieldType = getBaseFieldType({ type });
-        const handler = filterCreateRegistry.get(fieldType) || filterCreateRegistry.getDefault();
-        if (handler) {
-            return handler;
-        }
-        throw new WebinyError(
-            `There is no filter create handler for the field type "${fieldType}".`,
-            "MISSING_FILTER_CREATE_HANDLER",
-            { fieldType }
-        );
-    };
-
-    const createExpression = ({ where, condition }: CreateExpressionParams): Expression => {
-        const expression: Expression = {
-            filters: [],
-            expressions: [],
-            condition
-        };
-
-        for (const key in where) {
-            const value = where[key as keyof typeof where];
-            if (value === undefined) {
-                continue;
-            }
-
-            if (key === "AND") {
-                const childWhereList = getWhereValues(value, key);
-                const childExpression: Expression = {
-                    condition: "AND",
-                    filters: [],
-                    expressions: []
-                };
-                for (const childWhere of childWhereList) {
-                    const result = createExpression({
-                        where: childWhere,
-                        condition: "AND"
-                    });
-                    childExpression.expressions.push(result);
-                }
-                expression.expressions.push(childExpression);
-                continue;
-            }
-            if (key === "OR") {
-                const childWhereList = getWhereValues(value, key);
-                const childExpression: Expression = {
-                    condition: "OR",
-                    filters: [],
-                    expressions: []
-                };
-                for (const childWhere of childWhereList) {
-                    const result = createExpression({
-                        where: childWhere,
-                        condition: "AND"
-                    });
-                    childExpression.expressions.push(result);
-                }
-                expression.expressions.push(childExpression);
-                continue;
-            }
-
-            const whereParams = extractWhereParams(key);
-            if (!whereParams) {
-                continue;
-            }
-
-            const { fieldId, operation, negate } = whereParams;
-
-            const field = fields[fieldId];
-            if (!field) {
-                throw new WebinyError(
-                    `There is no field with the fieldId "${fieldId}".`,
-                    "FIELD_ERROR",
-                    { fieldId }
-                );
-            }
-
-            const handler = getHandler(field.type);
-            const fieldType = getBaseFieldType(field);
-            const transformHandler = transformRegistry.get(fieldType);
-
-            const transformValueCallable = (value: any) => {
-                if (!transformHandler) {
-                    return value;
-                }
-                return transformHandler.transform({ field, value });
-            };
-
-            const result = handler.create({
-                key,
-                value,
-                valueFilterRegistry,
-                transformRegistry,
-                getHandler,
-                operation,
-                negate,
-                field,
-                fields,
-                compareValue: transformValue({
-                    value,
-                    transform: transformValueCallable
-                }),
-                transformValue: transformValueCallable
-            });
-
-            if (!result || (Array.isArray(result) && result.length === 0)) {
-                continue;
-            }
-
-            expression.filters.push(...(Array.isArray(result) ? result : [result]));
-        }
-
-        return expression;
-    };
-
-    const expression = createExpression({
-        where,
-        condition: "AND"
-    });
-
-    if (expression.filters.length > 0 || expression.expressions.length !== 1) {
-        return expression;
-    }
-    return expression.expressions[0];
-};

package/src/filtering/fields/createFields.ts

@@ -1,124 +0,0 @@
-import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
-import { createSystemFields } from "./systemFields.js";
-import type { Field, FieldParent } from "./types.js";
-import type { FieldFilterPathRegistry } from "../../features/fieldFilterPath/abstractions.js";
-import type { FieldFilterValueTransformRegistry } from "../../features/fieldFilterValueTransform/abstractions.js";
-import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-
-interface Params {
-    fields: CmsModelField[];
-    pathRegistry: FieldFilterPathRegistry.Interface;
-    transformRegistry: FieldFilterValueTransformRegistry.Interface;
-}
-
-interface FieldCollection {
-    [key: string]: Field;
-}
-
-interface AddFieldsToCollectionParams {
-    fields: CmsModelField[];
-    parents: FieldParent[];
-    pathRegistry: FieldFilterPathRegistry.Interface;
-    transformRegistry: FieldFilterValueTransformRegistry.Interface;
-    system: boolean;
-}
-
-const createFieldCollection = (params: AddFieldsToCollectionParams): FieldCollection => {
-    const { fields, parents, pathRegistry, transformRegistry, system } = params;
-    return fields.reduce<FieldCollection>((collection, field) => {
-        const fieldType = getBaseFieldType(field);
-        const transformHandler = transformRegistry.get(fieldType);
-        const pathHandler = pathRegistry.get(fieldType);
-
-        const fieldId = [
-            ...parents,
-            {
-                fieldId: field.fieldId,
-                list: field.list
-            }
-        ]
-            .map(f => f.fieldId)
-            .join(".");
-
-        collection[fieldId] = {
-            ...field,
-            parents,
-            system,
-            createPath: pathParams => {
-                if (
-                    pathHandler &&
-                    pathHandler.canUse(
-                        field,
-                        parents.map(p => p.fieldId)
-                    )
-                ) {
-                    return pathHandler.createPath(pathParams);
-                }
-
-                return parents
-                    .map(parent => parent.fieldId)
-                    .concat([pathParams.field.fieldId])
-                    .join(".");
-            },
-            transform: value => {
-                if (!transformHandler) {
-                    return value;
-                }
-                return transformHandler.transform({
-                    field,
-                    value
-                });
-            }
-        };
-        const childFields = field.settings?.fields;
-        if (!childFields?.length) {
-            return collection;
-        }
-
-        const result = createFieldCollection({
-            fields: childFields,
-            parents: [
-                ...parents,
-                {
-                    fieldId: field.fieldId,
-                    list: field.list
-                }
-            ],
-            pathRegistry,
-            transformRegistry,
-            system
-        });
-        Object.assign(collection, result);
-        return collection;
-    }, {});
-};
-
-export const createFields = (params: Params) => {
-    const { fields, pathRegistry, transformRegistry } = params;
-
-    const collection = createFieldCollection({
-        fields: createSystemFields(),
-        pathRegistry,
-        transformRegistry,
-        parents: [],
-        system: true
-    });
-
-    const result = createFieldCollection({
-        fields,
-        pathRegistry,
-        transformRegistry,
-        parents: [
-            {
-                fieldId: "values",
-                list: false
-            }
-        ],
-        system: false
-    });
-
-    return {
-        ...collection,
-        ...result
-    };
-};

package/src/filtering/fields/extractSort.ts

@@ -1,97 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { Field } from "./types.js";
-import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
-import type { FieldSortingRegistry } from "../../features/fieldSorting/abstractions.js";
-
-const extractSortInfo = (sortBy: string) => {
-    const rootSorting = sortBy.match(/^([a-zA-Z]+)_(ASC|DESC)$/);
-    if (rootSorting) {
-        return {
-            fieldId: rootSorting[1],
-            isValues: false,
-            order: rootSorting[2] as "ASC" | "DESC"
-        };
-    }
-    const valuesSorting = sortBy.match(/^values_([a-zA-Z0-9]+)_(ASC|DESC)$/);
-    if (valuesSorting) {
-        return {
-            fieldId: valuesSorting[1],
-            isValues: true,
-            order: valuesSorting[2] as "ASC" | "DESC"
-        };
-    }
-    throw new WebinyError(
-        "Problem in determining the sorting for the entry items.",
-        "SORT_EXTRACT_ERROR",
-        {
-            sortBy
-        }
-    );
-};
-
-interface IResponse {
-    valuePath: string;
-    reverse: boolean;
-    fieldId: string;
-    field: Field;
-}
-
-interface IParams {
-    model: CmsModel;
-    sortBy: string;
-    fields: Record<string, Field>;
-    sortingRegistry: FieldSortingRegistry.Interface;
-}
-
-export const extractSort = (params: IParams): IResponse => {
-    const { model, sortBy, fields, sortingRegistry } = params;
-    const { fieldId, isValues: isValuesSorting, order } = extractSortInfo(sortBy);
-
-    const field = Object.values(fields).find(f => {
-        const isValues = f.parents[0]?.fieldId === "values";
-        if (isValues && isValuesSorting) {
-            return f.fieldId === fieldId;
-        }
-        if (f.parents.length > 0) {
-            return false;
-        }
-        return f.fieldId === fieldId;
-    });
-
-    const handler = sortingRegistry.find({
-        model,
-        field,
-        fieldId,
-        order,
-        sortBy
-    });
-
-    if (handler) {
-        return handler.createSort({
-            model,
-            fieldId,
-            order,
-            sortBy,
-            field,
-            fields
-        });
-    } else if (!field) {
-        throw new WebinyError(
-            "Sorting field does not exist in the content model.",
-            "SORTING_FIELD_ERROR",
-            {
-                fieldId,
-                fields
-            }
-        );
-    }
-    const valuePath = field.createPath({
-        field
-    });
-    return {
-        field,
-        fieldId,
-        valuePath,
-        reverse: order === "DESC"
-    };
-};

package/src/filtering/fields/systemFields.ts

@@ -1,165 +0,0 @@
-import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
-import {
-    ENTRY_META_FIELDS,
-    isDateTimeEntryMetaField,
-    isIdentityEntryMetaField
-} from "@webiny/api-headless-cms/constants.js";
-import lodashStartCase from "lodash/startCase.js";
-import { createModelField } from "@webiny/api-headless-cms";
-
-export const createSystemFields = (): CmsModelField[] => {
-    const onMetaFields = ENTRY_META_FIELDS.filter(isDateTimeEntryMetaField).map<CmsModelField>(
-        fieldName => {
-            return createModelField({
-                id: fieldName,
-                type: "datetime",
-                storageId: fieldName,
-                fieldId: fieldName,
-                label: lodashStartCase(fieldName)
-            });
-        }
-    );
-
-    const byMetaFields = ENTRY_META_FIELDS.filter(isIdentityEntryMetaField).map<CmsModelField>(
-        fieldName => {
-            return createModelField({
-                id: fieldName,
-                type: "plainObject",
-                storageId: fieldName,
-                fieldId: fieldName,
-                label: lodashStartCase(fieldName),
-                settings: {
-                    path: `${fieldName}.id`
-                }
-            });
-        }
-    );
-
-    return [
-        createModelField({
-            id: "id",
-            type: "text",
-            storageId: "id",
-            fieldId: "id",
-            label: "ID"
-        }),
-        createModelField({
-            id: "entryId",
-            type: "text",
-            storageId: "entryId",
-            fieldId: "entryId",
-            label: "Entry ID"
-        }),
-
-        ...onMetaFields,
-        ...byMetaFields,
-
-        createModelField({
-            id: "meta",
-            type: "plainObject",
-            storageId: "meta",
-            fieldId: "meta",
-            label: "Meta"
-        }),
-        createModelField({
-            id: "wbyAco_location",
-            type: "object",
-            storageId: "location",
-            label: "Location",
-            fieldId: "wbyAco_location",
-            settings: {
-                fields: [
-                    createModelField({
-                        id: "folderId",
-                        type: "text",
-                        fieldId: "folderId",
-                        label: "Folder ID",
-                        storageId: "folderId",
-                        settings: {
-                            path: "location.folderId"
-                        }
-                    })
-                ]
-            }
-        }),
-
-        createModelField({
-            id: "version",
-            type: "number",
-            storageId: "version",
-            fieldId: "version",
-            label: "Version"
-        }),
-        createModelField({
-            id: "status",
-            type: "text",
-            storageId: "status",
-            fieldId: "status",
-            label: "Status"
-        }),
-        createModelField({
-            id: "wbyDeleted",
-            type: "boolean",
-            storageId: "wbyDeleted",
-            fieldId: "wbyDeleted",
-            label: "Deleted"
-        }),
-        createModelField({
-            id: "state",
-            type: "object",
-            storageId: "object@state",
-            fieldId: "state",
-            label: "State",
-            settings: {
-                fields: [
-                    createModelField({
-                        id: "stepId",
-                        type: "text",
-                        fieldId: "stepId",
-                        label: "Step ID",
-                        storageId: "stepId"
-                    }),
-                    createModelField({
-                        id: "stepName",
-                        type: "text",
-                        fieldId: "stepName",
-                        label: "Step Name",
-                        storageId: "stepName"
-                    }),
-                    createModelField({
-                        id: "state",
-                        type: "text",
-                        fieldId: "state",
-                        label: "State",
-                        storageId: "state"
-                    })
-                ]
-            }
-        }),
-        createModelField({
-            id: "values",
-            type: "object",
-            storageId: "values",
-            fieldId: "values",
-            label: "Values"
-        }),
-        createModelField({
-            id: "live",
-            type: "object",
-            storageId: "live",
-            fieldId: "live",
-            label: "Live",
-            settings: {
-                fields: [
-                    createModelField({
-                        id: "version",
-                        type: "number",
-                        fieldId: "version",
-                        label: "Version",
-                        storageId: "version"
-                    })
-                ]
-            }
-        })
-    ];
-};

package/src/filtering/fields/types.ts

@@ -1,46 +0,0 @@
-import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
-import type { CreatePathCallable } from "../../plugins/CmsEntryFieldFilterPathPlugin.js";
-
-interface FieldValueTransform {
-    (value: any): any;
-}
-
-export interface FieldParent {
-    fieldId: string;
-    list?: boolean;
-}
-
-export interface Field
-    extends
-        Partial<Omit<CmsModelField, "id" | "type" | "storageId" | "fieldId">>,
-        Pick<CmsModelField, "id" | "type" | "storageId" | "fieldId"> {
-    /*
-     * A list of fieldId of all parents of the current field.
-     *
-     * This is used to check if we need to iterate through an array of parent values.
-     */
-    parents: FieldParent[];
-    /*
-     * The method which creates a path for the filtering.
-     *
-     * Always exists. In most cases it will return some fixed value.
-     * When having a CmsEntryFieldFilterPathPlugin then it is executed to create a path.
-     */
-    createPath: CreatePathCallable;
-    /*
-     * In most cases, return value of this method is what ever is the input.
-     *
-     * In some cases there might be a CmsFieldFilterValueTransformPlugin, which transforms value to a comparable one.
-     * For example, time in format 15:45:58 is not comparable, so we transform it into the seconds and then compare.
-     */
-    transform: FieldValueTransform;
-    /*
-     * Is the field a system field?
-     * System fields are built into the code and cannot be changed.
-     */
-    system: boolean;
-}
-
-export interface FilterItemFromStorage {
-    <T = any>(field: CmsModelField, value: any): Promise<T>;
-}