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

package/src/filtering/transform.ts

@@ -1,11 +0,0 @@
-import type { Field } from "./fields/types.js";
-
-interface Params extends Pick<Field, "transform"> {
-    value: any;
-}
-export const transformValue = ({ value, transform }: Params): any => {
-    if (Array.isArray(value)) {
-        return value.map(v => transform(v));
-    }
-    return transform(value);
-};

package/src/filtering/values.ts

@@ -1,24 +0,0 @@
-import type { CmsEntryListWhere } from "@webiny/api-headless-cms/types/index.js";
-import WebinyError from "@webiny/error";
-
-export const getWhereValues = (value: unknown, condition: "AND" | "OR") => {
-    const values = value as CmsEntryListWhere[] | undefined;
-    if (!Array.isArray(values)) {
-        throw new WebinyError(
-            `Trying to run filtering with "${condition}", but the value sent is not an array.`,
-            `MALFORMED_${condition}_CONDITION`,
-            {
-                value
-            }
-        );
-    } else if (values.length === 0) {
-        throw new WebinyError(
-            `Trying to run filtering with "${condition}", but the value sent is empty array.`,
-            `MALFORMED_${condition}_CONDITION`,
-            {
-                value
-            }
-        );
-    }
-    return values;
-};

package/src/filtering/where.ts

@@ -1,24 +0,0 @@
-export const extractWhereParams = (key: string) => {
-    const isWbyAco = key.match("wbyAco_") !== null;
-    const result = key.replace("wbyAco_", "").split("_");
-    const fieldId = result.shift();
-    if (!fieldId) {
-        return null;
-    }
-    const rawOp = result.length === 0 ? "eq" : result.join("_");
-    /* When rawOp is not, it means it is equal negated so just return that. */
-    if (rawOp === "not") {
-        return {
-            fieldId,
-            operation: "eq",
-            negate: true
-        };
-    }
-    const negate = rawOp.match("not_") !== null;
-    const operation = rawOp.replace("not_", "");
-    return {
-        fieldId: isWbyAco ? `wbyAco_${fieldId}` : fieldId,
-        operation,
-        negate
-    };
-};

package/src/handlers/datetimeTransformHandler.ts

@@ -1,52 +0,0 @@
-import { parseISO } from "date-fns";
-import type { FieldFilterValueTransformRegistry } from "../features/fieldFilterValueTransform/abstractions.js";
-
-const transformTime = (value: any): number => {
-    if (value === undefined || value === null) {
-        throw new Error(`Time value is null or undefined.`);
-    } else if (typeof value === "boolean" || value === "" || Array.isArray(value)) {
-        throw new Error("Field value must be a string because field is defined as time.");
-    }
-    const converted = Number(`${value}`);
-    if (typeof value === "number" || isNaN(converted) === false) {
-        return Number(value);
-    } else if (typeof value !== "string") {
-        throw new Error("Field value must be a string because field is defined as time.");
-    }
-    const [time, milliseconds = 0] = value.split(".");
-    const values = time.split(":").map(Number);
-    if (values.length < 2) {
-        throw new Error("Time must contain at least hours and minutes.");
-    }
-    const [hours, minutes, seconds = 0] = values;
-    return (hours * 60 * 60 + minutes * 60 + seconds) * 1000 + Number(milliseconds);
-};
-
-const transformDateTime = (value: any): number | null => {
-    if (value === null || value === undefined) {
-        return null;
-    } else if (typeof value === "string") {
-        const parsedDateTime = parseISO(value).getTime();
-        if (isNaN(parsedDateTime) === false) {
-            return parsedDateTime;
-        }
-    } else if (value instanceof Date || typeof (value as unknown as Date)?.getTime === "function") {
-        return value.getTime();
-    }
-    console.warn("Could not parse given dateTime value.", "PARSE_DATE_ERROR", {
-        value
-    });
-    return null;
-};
-
-export const createDatetimeTransformHandler = (): FieldFilterValueTransformRegistry.Handler => {
-    return {
-        transform: ({ field, value }) => {
-            const { type } = field.settings || {};
-            if (type === "time") {
-                return transformTime(value);
-            }
-            return transformDateTime(value);
-        }
-    };
-};

package/src/handlers/defaultFilterCreateHandler.ts

@@ -1,31 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
-
-export const createDefaultFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {
-    return {
-        create: params => {
-            const { negate, transformValue, field, compareValue, valueFilterRegistry } = params;
-            const filter = valueFilterRegistry.get(params.operation);
-            if (!filter) {
-                throw new WebinyError(
-                    `Missing ValueFilterPlugin for operation "${params.operation}".`,
-                    "MISSING_OPERATION_PLUGIN",
-                    {
-                        operation: params.operation
-                    }
-                );
-            }
-            return {
-                negate,
-                transformValue,
-                field,
-                compareValue,
-                fieldPathId: [...field.parents.map(f => f.fieldId), field.fieldId].join("."),
-                path: field.createPath({
-                    field
-                }),
-                filter
-            };
-        }
-    };
-};

package/src/handlers/locationFolderIdPathHandler.ts

@@ -1,24 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { FieldFilterPathRegistry } from "../features/fieldFilterPath/abstractions.js";
-
-export const createLocationFolderIdPathHandler = (): FieldFilterPathRegistry.Handler => {
-    return {
-        canUse: (field, parents) => {
-            if (field.fieldId !== "folderId") {
-                return false;
-            } else if (!parents?.length) {
-                return false;
-            }
-            return parents[0] === "wbyAco_location";
-        },
-        createPath: ({ field }) => {
-            const { path } = field.settings || {};
-            if (!path) {
-                throw new WebinyError("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
-                    field
-                });
-            }
-            return path;
-        }
-    };
-};

package/src/handlers/objectFilterCreateHandler.ts

@@ -1,86 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
-import { extractWhereParams } from "../filtering/where.js";
-import { transformValue } from "../filtering/transform.js";
-import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-
-export const createObjectFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {
-    return {
-        create: params => {
-            const {
-                value: objectValue,
-                valueFilterRegistry,
-                transformRegistry,
-                getHandler,
-                field: parentField,
-                fields
-            } = params;
-
-            const filters: FieldFilterCreateRegistry.Result[] = [];
-
-            for (const key in objectValue) {
-                const value = objectValue[key];
-                if (value === undefined) {
-                    continue;
-                }
-                const whereParams = extractWhereParams(key);
-                if (!whereParams) {
-                    continue;
-                }
-                const { negate, fieldId, operation } = whereParams;
-
-                const fieldPath = parentField.parents
-                    .map(p => p.fieldId)
-                    .concat([parentField.fieldId, fieldId])
-                    .join(".");
-
-                const field = fields[fieldPath];
-                if (!field) {
-                    throw new WebinyError(
-                        `There is no field with the field path "${fieldPath}".`,
-                        "FIELD_ERROR",
-                        { fieldId }
-                    );
-                }
-
-                const fieldType = getBaseFieldType(field);
-                const handler = getHandler(fieldType);
-                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) {
-                    continue;
-                }
-                if (Array.isArray(result)) {
-                    filters.push(...result);
-                    continue;
-                }
-
-                filters.push(result);
-            }
-            return filters;
-        }
-    };
-};

package/src/handlers/plainObjectPathHandler.ts

@@ -1,17 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { FieldFilterPathRegistry } from "../features/fieldFilterPath/abstractions.js";
-
-export const createPlainObjectPathHandler = (): FieldFilterPathRegistry.Handler => {
-    return {
-        canUse: () => true,
-        createPath: ({ field }) => {
-            const { path } = field.settings || {};
-            if (!path) {
-                throw new WebinyError("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
-                    field
-                });
-            }
-            return path;
-        }
-    };
-};

package/src/handlers/refFilterCreateHandler.ts

@@ -1,65 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
-import { extractWhereParams } from "../filtering/where.js";
-import { transformValue } from "../filtering/transform.js";
-import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-
-export const createRefFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {
-    return {
-        create: params => {
-            const { valueFilterRegistry, transformRegistry, field } = params;
-            let value = params.value;
-            if (!value) {
-                value = { entryId: null };
-            }
-            const propertyFilters = Object.keys(value);
-            if (propertyFilters.length === 0) {
-                return null;
-            }
-            const filters: FieldFilterCreateRegistry.Result[] = [];
-
-            for (const propertyFilter of propertyFilters) {
-                const whereParams = extractWhereParams(propertyFilter);
-                if (!whereParams) {
-                    continue;
-                }
-                const { fieldId: propertyId, operation: propertyOperation, negate } = whereParams;
-
-                const fieldType = getBaseFieldType(field);
-                const transformHandler = transformRegistry.get(fieldType);
-
-                const transformValueCallable = (value: any) => {
-                    if (!transformHandler) {
-                        return value;
-                    }
-                    return transformHandler.transform({ field, value });
-                };
-
-                const filter = valueFilterRegistry.get(propertyOperation);
-                if (!filter) {
-                    throw new WebinyError(
-                        `Missing operation filter for "${propertyOperation}".`,
-                        "MISSING_OPERATION_FILTER"
-                    );
-                }
-
-                const paths = [field.createPath({ field }), propertyId];
-
-                filters.push({
-                    field,
-                    path: paths.join("."),
-                    fieldPathId: [...field.parents.map(f => f.fieldId), field.fieldId].join("."),
-                    filter,
-                    negate,
-                    compareValue: transformValue({
-                        value: value[propertyFilter],
-                        transform: transformValueCallable
-                    }),
-                    transformValue: transformValueCallable
-                });
-            }
-
-            return filters;
-        }
-    };
-};

package/src/handlers/searchableJsonFilterCreateHandler.ts

@@ -1,61 +0,0 @@
-import type { FieldFilterCreateRegistry } from "../features/fieldFilterCreate/abstractions.js";
-import { extractWhereParams } from "../filtering/where.js";
-
-function dotFlatten(obj: Record<string, any>, prefix = ""): Record<string, any> {
-    return Object.entries(obj).reduce<Record<string, any>>((acc, [key, val]) => {
-        const path = prefix ? `${prefix}.${key}` : key;
-        if (val && typeof val === "object" && !Array.isArray(val)) {
-            Object.assign(acc, dotFlatten(val, path));
-        } else {
-            acc[path] = val;
-        }
-        return acc;
-    }, {});
-}
-
-export const createSearchableJsonFilterCreateHandler = (): FieldFilterCreateRegistry.Handler => {
-    return {
-        create: params => {
-            const { value: objectValue, valueFilterRegistry, field: parentField } = params;
-
-            const filters: FieldFilterCreateRegistry.Result[] = [];
-            const accessPatterns = dotFlatten(objectValue);
-
-            for (const key in accessPatterns) {
-                const value = accessPatterns[key];
-                if (value === undefined) {
-                    continue;
-                }
-
-                const whereParams = extractWhereParams(key);
-                if (!whereParams) {
-                    continue;
-                }
-                const { negate, operation } = whereParams;
-
-                const transformValueCallable = (value: any) => {
-                    return value;
-                };
-
-                const fieldId = `${parentField.fieldId}.${whereParams.fieldId ?? key}`;
-
-                const filter = valueFilterRegistry.get(operation);
-                if (!filter) {
-                    console.error(`Missing operation filter for "${operation}".`);
-                    continue;
-                }
-
-                filters.push({
-                    field: parentField,
-                    path: `values.${fieldId}`,
-                    fieldPathId: `values.${fieldId}`,
-                    negate,
-                    filter,
-                    compareValue: value,
-                    transformValue: transformValueCallable
-                });
-            }
-            return filters;
-        }
-    };
-};

package/src/index.ts

@@ -1,63 +0,0 @@
-/* Filtering. */
-export { filter } from "./filtering/filter.js";
-export { sort } from "./filtering/sort.js";
-export { createFields } from "./filtering/fields/createFields.js";
-export { createFilterCreatePlugins } from "./filtering/plugins/index.js";
-export { createExpressions } from "./filtering/expressions/createExpressions.js";
-export type { Expression, ExpressionCondition } from "./filtering/expressions/createExpressions.js";
-export { getValue } from "./filtering/getValue.js";
-
-/* Plugin base classes. */
-export { CmsEntryFieldFilterPlugin } from "./plugins/CmsEntryFieldFilterPlugin.js";
-export type { CmsEntryFieldFilterPluginCreateResponse } from "./plugins/CmsEntryFieldFilterPlugin.js";
-export {
-    CmsEntryFieldSortingPlugin,
-    createCmsEntryFieldSortingPlugin
-} from "./plugins/CmsEntryFieldSortingPlugin.js";
-export { CmsEntryFieldFilterPathPlugin } from "./plugins/CmsEntryFieldFilterPathPlugin.js";
-export type { CreatePathCallable } from "./plugins/CmsEntryFieldFilterPathPlugin.js";
-export { CmsFieldFilterValueTransformPlugin } from "./plugins/CmsFieldFilterValueTransformPlugin.js";
-
-/* Path + transform plugins. */
-export { createPlainObjectPathPlugin } from "./path/plainObject.js";
-export { createLocationFolderIdPathPlugin } from "./path/locationFolderId.js";
-export { createDatetimeTransformValuePlugin } from "./transforms/datetime.js";
-
-/* CMS storage helpers. */
-export {
-    createStorageModelAccessor,
-    createStorageTransformCallable,
-    aggregateUniqueFieldValues
-} from "./cms/storageHelpers.js";
-
-/* Types. */
-export type { Field } from "./filtering/fields/types.js";
-export type { FilterItemFromStorage } from "./filtering/fields/types.js";
-
-/* DI registries. */
-export {
-    FieldFilterPathRegistry,
-    type IFieldFilterPathHandler,
-    type IFieldFilterPathRegistry
-} from "./features/fieldFilterPath/abstractions.js";
-export {
-    FieldFilterValueTransformRegistry,
-    type IFieldFilterValueTransformHandler,
-    type IFieldFilterValueTransformRegistry
-} from "./features/fieldFilterValueTransform/abstractions.js";
-export {
-    FieldFilterCreateRegistry,
-    type IFieldFilterCreateHandler,
-    type IFieldFilterCreateParams,
-    type IFieldFilterCreateRegistry,
-    type IFieldFilterCreateResult
-} from "./features/fieldFilterCreate/abstractions.js";
-export {
-    FieldSortingRegistry,
-    type IFieldSortingCanUseParams,
-    type IFieldSortingCreateParams,
-    type IFieldSortingHandler,
-    type IFieldSortingRegistry,
-    type IFieldSortingResult
-} from "./features/fieldSorting/abstractions.js";
-export { FilterRegistriesFeature } from "./features/FilterRegistriesFeature.js";

package/src/path/locationFolderId.ts

@@ -1,29 +0,0 @@
-/* File is @internal. */
-import WebinyError from "@webiny/error";
-import type { CreatePathCallable } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
-import { CmsEntryFieldFilterPathPlugin } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
-
-const createPath: CreatePathCallable = ({ field }) => {
-    const { path } = field.settings || {};
-    if (!path) {
-        throw new WebinyError("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
-            field
-        });
-    }
-    return path;
-};
-
-export const createLocationFolderIdPathPlugin = (): CmsEntryFieldFilterPathPlugin => {
-    return new CmsEntryFieldFilterPathPlugin({
-        fieldType: "text",
-        path: createPath,
-        canUse: (field, parents) => {
-            if (field.fieldId !== "folderId") {
-                return false;
-            } else if (!parents?.length) {
-                return false;
-            }
-            return parents[0] === "wbyAco_location";
-        }
-    });
-};

package/src/path/plainObject.ts

@@ -1,21 +0,0 @@
-/* File is @internal. */
-import WebinyError from "@webiny/error";
-import type { CreatePathCallable } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
-import { CmsEntryFieldFilterPathPlugin } from "../plugins/CmsEntryFieldFilterPathPlugin.js";
-
-const createPath: CreatePathCallable = ({ field }) => {
-    const { path } = field.settings || {};
-    if (!path) {
-        throw new WebinyError("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
-            field
-        });
-    }
-    return path;
-};
-
-export const createPlainObjectPathPlugin = (): CmsEntryFieldFilterPathPlugin => {
-    return new CmsEntryFieldFilterPathPlugin({
-        fieldType: "plainObject",
-        path: createPath
-    });
-};

package/src/plugins/CmsEntryFieldFilterPathPlugin.ts

@@ -1,58 +0,0 @@
-import WebinyError from "@webiny/error";
-import { Plugin } from "@webiny/plugins/Plugin.js";
-import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
-
-export interface CreatePathCallableParams {
-    field: Partial<CmsModelField> & Pick<CmsModelField, "fieldId" | "storageId" | "id">;
-    index?: number;
-}
-export interface CreatePathCallable {
-    (params: CreatePathCallableParams): string;
-}
-export interface CmsEntryFieldFilterPathPluginParams {
-    fieldType: string;
-    fieldId?: string[];
-    path: string | CreatePathCallable;
-    canUse?: (field: Pick<CmsModelField, "fieldId" | "type">, parents?: string[]) => boolean;
-}
-export class CmsEntryFieldFilterPathPlugin extends Plugin {
-    public static override readonly type: string = "cms-field-filter-path";
-
-    private readonly config: CmsEntryFieldFilterPathPluginParams;
-
-    public get fieldType(): string {
-        return this.config.fieldType;
-    }
-
-    public constructor(config: CmsEntryFieldFilterPathPluginParams) {
-        super();
-
-        this.config = config;
-
-        /* We expect error here because we know that `this.constructor.type` is defined, but TS does not. */
-        // @ts-expect-error
-        this.name = `${this.constructor.type}-${this.config.fieldType}`;
-    }
-
-    public canUse(field: Pick<CmsModelField, "fieldId" | "type">, parents: string[]): boolean {
-        if (field.type !== this.config.fieldType) {
-            return false;
-        } else if (this.config.canUse) {
-            return this.config.canUse(field, parents);
-        }
-        const fieldId = this.config.fieldId;
-        if (!fieldId || Array.isArray(fieldId) === false || fieldId.length === 0) {
-            return true;
-        }
-        return fieldId.includes(field.fieldId);
-    }
-
-    public createPath(params: CreatePathCallableParams): string {
-        if (typeof this.config.path === "function") {
-            return this.config.path(params);
-        } else if (typeof this.config.path === "string") {
-            return this.config.path;
-        }
-        throw new WebinyError(`Missing path in "${this.name}" plugin.`);
-    }
-}

package/src/plugins/CmsEntryFieldFilterPlugin.ts

@@ -1,59 +0,0 @@
-import { Plugin } from "@webiny/plugins";
-import type { Field } from "~/filtering/fields/types.js";
-import type { ICmsFieldFilterValueTransformPlugin } from "./CmsFieldFilterValueTransformPlugin.js";
-import { ValueFilterRegistry } from "@webiny/db-utils";
-
-/*
- * This plugin is used to create the filter.
- * Internally we have default one + the one for the reference field - because it is actually an object when filtering.
- */
-
-interface CmsEntryFieldFilterPluginParams<T = any> {
-    fieldType: string;
-    create: (
-        params: CmsEntryFieldFilterPluginCreateParams<T>
-    ) => null | CmsEntryFieldFilterPluginCreateResponse | CmsEntryFieldFilterPluginCreateResponse[];
-}
-
-interface CmsEntryFieldFilterPluginCreateParams<T = any> {
-    key: string;
-    value: T;
-    field: Field;
-    fields: Record<string, Field>;
-    operation: string;
-    valueFilterRegistry: ValueFilterRegistry.Interface;
-    transformValuePlugins: Record<string, ICmsFieldFilterValueTransformPlugin>;
-    getFilterCreatePlugin: (type: string) => CmsEntryFieldFilterPlugin;
-    negate: boolean;
-    compareValue: any;
-    transformValue: <I = any, O = any>(value: I) => O;
-}
-
-export interface CmsEntryFieldFilterPluginCreateResponse {
-    field: Field;
-    path: string;
-    fieldPathId: string;
-    filter: ValueFilterRegistry.Filter;
-    negate: boolean;
-    compareValue: any;
-    transformValue: <I = any, O = any>(value: I) => O;
-}
-
-export class CmsEntryFieldFilterPlugin<T = any> extends Plugin {
-    public static override readonly type: string = "cms.dynamodb.entry.field.filter";
-    public static readonly ALL: string = "*";
-
-    private readonly config: CmsEntryFieldFilterPluginParams<T>;
-
-    public readonly fieldType: string;
-
-    public constructor(config: CmsEntryFieldFilterPluginParams<T>) {
-        super();
-        this.config = config;
-        this.fieldType = this.config.fieldType;
-    }
-
-    public create(params: CmsEntryFieldFilterPluginCreateParams<T>) {
-        return this.config.create(params);
-    }
-}