@webiny/api-headless-cms-storage 0.0.0-unstable.9f53ea597d → 6.6.0-alpha.0

package/src/filtering/expressions/createExpressions.ts

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,165 @@
+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

@@ -0,0 +1,46 @@
+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>;
+}