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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/api-headless-cms-storage",
-	"version": "6.6.0-alpha.0",
+	"version": "6.6.0-alpha.1",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"type": "module",
@@ -10,21 +10,26 @@
 		"directory": "packages/api-headless-cms-storage"
 	},
 	"dependencies": {
-		"@webiny/api": "6.6.0-alpha.0",
-		"@webiny/api-headless-cms": "6.6.0-alpha.0",
-		"@webiny/db-utils": "6.6.0-alpha.0",
-		"@webiny/di": "^1.0.2",
-		"@webiny/error": "6.6.0-alpha.0",
-		"@webiny/feature": "6.6.0-alpha.0",
-		"@webiny/plugins": "6.6.0-alpha.0",
-		"date-fns": "^4.4.0",
-		"dot-prop": "^10.2.0",
-		"lodash": "^4.18.1"
+		"@webiny/api": "6.6.0-alpha.1",
+		"@webiny/api-headless-cms": "6.6.0-alpha.1",
+		"@webiny/db-utils": "6.6.0-alpha.1",
+		"@webiny/di": "1.1.0",
+		"@webiny/error": "6.6.0-alpha.1",
+		"@webiny/feature": "6.6.0-alpha.1",
+		"@webiny/plugins": "6.6.0-alpha.1",
+		"date-fns": "4.4.0",
+		"dot-prop": "10.2.0",
+		"lodash": "4.18.1"
 	},
 	"devDependencies": {
-		"@webiny/build-tools": "6.6.0-alpha.0",
-		"@webiny/project-utils": "6.6.0-alpha.0",
-		"typescript": "^7.0.2",
-		"vitest": "^4.1.10"
+		"@webiny/build-tools": "6.6.0-alpha.1",
+		"typescript": "7.0.2",
+		"vitest": "4.1.11"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	},
+	"publishConfig": {
+		"access": "public"
 	}
 }

package/__tests__/filtering/getValue.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getValue } from "~/filtering/getValue";
-import { createEntry } from "./mocks/entry.noModel";
-
-describe("value via object-path", () => {
-    it("should find values complex object / array structure", async () => {
-        const title = getValue(createEntry(), "values.title");
-        expect(title).toEqual(createEntry().values.title);
-
-        const options = getValue(createEntry(), "values.options");
-        expect(options).toEqual(createEntry().values.options);
-
-        const variantTitle = getValue(createEntry(), "values.variant.title");
-        expect(variantTitle).toEqual(createEntry().values.variant.title);
-
-        const variantSpecificationsKey = getValue(
-            createEntry(),
-            "values.variant.specifications.key"
-        );
-
-        expect(variantSpecificationsKey).toEqual([
-            "Specification #1",
-            "Specification #2",
-            "Specification #3"
-        ]);
-
-        const variantSpecificationsInfoImages = getValue(
-            createEntry(),
-            "values.variant.specifications.info.images"
-        );
-        expect(variantSpecificationsInfoImages).toEqual([
-            { files: ["image1.jpg", "image2.jpg", "image3.jpg", "image4.jpg"] },
-            { files: ["image31.jpg", "image32.jpg", "image33.jpg", "image34.jpg"] }
-        ]);
-
-        const variantSpecificationsInfoImagesFiles = getValue(
-            createEntry(),
-            "values.variant.specifications.info.images.files"
-        );
-        expect(variantSpecificationsInfoImagesFiles).toEqual([
-            "image1.jpg",
-            "image2.jpg",
-            "image3.jpg",
-            "image4.jpg",
-            "image31.jpg",
-            "image32.jpg",
-            "image33.jpg",
-            "image34.jpg"
-        ]);
-
-        const variantSpecificationsInfoTagsKey = getValue(
-            createEntry(),
-            "values.variant.specifications.info.tags.key"
-        );
-
-        expect(variantSpecificationsInfoTagsKey).toEqual(["size", "weight", "price"]);
-    });
-});

package/__tests__/filtering/mocks/entry.noModel.ts

@@ -1,110 +0,0 @@
-import type { CmsEntry } from "@webiny/api-headless-cms/types";
-
-interface ValuesOption {
-    title: string;
-    value: number;
-}
-
-interface ValuesVariantSpecification {
-    key: string;
-    value: string | number;
-    info?: {
-        [key: string]: any;
-    };
-}
-interface ValuesVariant {
-    title: string;
-    specifications: ValuesVariantSpecification[];
-}
-interface Values {
-    title: string;
-    options: ValuesOption[];
-    variant: ValuesVariant;
-}
-
-type Result = Pick<CmsEntry<Values>, "id" | "createdBy" | "createdOn" | "values">;
-
-const createCreatedOn = (index: number) => {
-    const d = new Date();
-    d.setTime(d.getTime() + index * 1000 * 86400);
-
-    return d.toISOString();
-};
-
-export const createEntry = (index = 0): Result => {
-    return {
-        id: `${index + 100000}#0001`,
-        createdOn: createCreatedOn(index),
-        createdBy: {
-            id: "userId",
-            type: "admin",
-            displayName: "Admin"
-        },
-        values: {
-            title: `Title #${String(index).padStart(5, "t")}`,
-            options: Array.from({ length: 100 }).map((_, optionIndex) => {
-                return {
-                    title: `Option #${index + optionIndex + 1}`,
-                    value: index + optionIndex + 1
-                };
-            }),
-            variant: {
-                title: `Variant title ${String(index).padStart(5, "a")}`,
-                specifications: [
-                    {
-                        key: `Specification #${index === 0 ? 1 : index}`,
-                        value: `${index + 100}`,
-                        info: {
-                            images: {
-                                files: ["image1.jpg", "image2.jpg", "image3.jpg", "image4.jpg"]
-                            },
-                            tags: [
-                                {
-                                    key: "size",
-                                    value: 55
-                                },
-                                {
-                                    key: "weight",
-                                    value: 105
-                                },
-                                {
-                                    key: "price",
-                                    value: 999
-                                }
-                            ]
-                        }
-                    },
-                    {
-                        key: "Specification #2",
-                        value: "2"
-                    },
-                    {
-                        key: "Specification #3",
-                        value: "3",
-                        info: {
-                            images: {
-                                files: ["image31.jpg", "image32.jpg", "image33.jpg", "image34.jpg"]
-                            },
-                            tags: [
-                                {
-                                    key: "size",
-                                    value: 355
-                                },
-                                {
-                                    key: "price",
-                                    value: 3999
-                                }
-                            ]
-                        }
-                    }
-                ]
-            }
-        }
-    };
-};
-
-export const createEntries = (amount: number) => {
-    return [...Array(amount)].map((_, index) => {
-        return createEntry(index);
-    });
-};

package/__tests__/path/plainObject.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CmsModelField } from "@webiny/api-headless-cms/types";
-import { createPlainObjectPathPlugin } from "~/path/plainObject";
-
-describe("dynamodb path plain object", () => {
-    it("should get the plain object path", () => {
-        const plugin = createPlainObjectPathPlugin();
-
-        const result = plugin.createPath({
-            field: {
-                storageId: "authors",
-                settings: {
-                    path: "createdBy.id"
-                }
-            } as unknown as CmsModelField
-        });
-
-        expect(result).toEqual("createdBy.id");
-    });
-
-    it("should throw an error when no path in the settings", () => {
-        const plugin = createPlainObjectPathPlugin();
-
-        expect(() => {
-            plugin.createPath({
-                field: {
-                    settings: {}
-                } as unknown as CmsModelField
-            });
-        }).toThrow("Missing path settings value.");
-    });
-});

package/__tests__/transforms/datetime.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createDatetimeTransformValuePlugin } from "~/transforms/datetime";
-import { CmsModelField } from "@webiny/api-headless-cms/types";
-
-const createField = (fieldType: string): CmsModelField => {
-    return {
-        id: "storageId",
-        storageId: "storageId",
-        type: "datetime",
-        settings: {
-            type: fieldType
-        }
-    } as unknown as CmsModelField;
-};
-
-describe("dynamodb transform datetime", () => {
-    const correctValues: [string | Date, string, number][] = [
-        [new Date("Thu, 13 May 2021 12:32:33.892 GMT"), "date", 1620909153892],
-        [new Date("2021-05-13T12:32:33.892Z"), "date", 1620909153892],
-        ["2021-05-13T12:32:33.892Z", "date", 1620909153892],
-        ["13:57:22", "time", 50242000],
-        ["13:57", "time", 50220000],
-        ["13:57.481", "time", 50220481],
-        ["13:57:22.581", "time", 50242581]
-    ];
-    it.each(correctValues)(
-        "should transform date or time into the milliseconds - %s",
-        (value: Date | string, fieldType: string, expected: number) => {
-            const plugin = createDatetimeTransformValuePlugin();
-
-            const result = plugin.transform({
-                field: createField(fieldType),
-                value
-            });
-
-            expect(result).toEqual(expected);
-        }
-    );
-
-    const incorrectTimeValues: [any][] = [
-        [{}],
-        [[]],
-        [""],
-        [
-            function () {
-                return 1;
-            }
-        ],
-        [true]
-    ];
-
-    it.each(incorrectTimeValues)(
-        "should throw an error when trying to transform time field but value is not a string or a number",
-        value => {
-            expect.assertions(1);
-            const plugin = createDatetimeTransformValuePlugin();
-
-            try {
-                const result = plugin.transform({
-                    field: createField("time"),
-                    value
-                });
-                expect(result).toEqual("SHOULD NOT HAPPEN");
-            } catch (ex) {
-                expect(ex.message).toEqual(
-                    "Field value must be a string because field is defined as time."
-                );
-            }
-        }
-    );
-});

package/dist/package.json

@@ -1,30 +0,0 @@
-{
-	"name": "@webiny/api-headless-cms-storage",
-	"version": "0.0.0",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"type": "module",
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/webiny/webiny-js.git",
-		"directory": "packages/api-headless-cms-storage"
-	},
-	"dependencies": {
-		"@webiny/api": "0.0.0",
-		"@webiny/api-headless-cms": "0.0.0",
-		"@webiny/db-utils": "0.0.0",
-		"@webiny/di": "1.0.2",
-		"@webiny/error": "0.0.0",
-		"@webiny/feature": "0.0.0",
-		"@webiny/plugins": "0.0.0",
-		"date-fns": "4.4.0",
-		"dot-prop": "10.2.0",
-		"lodash": "4.18.1"
-	},
-	"devDependencies": {
-		"@webiny/build-tools": "0.0.0",
-		"@webiny/project-utils": "0.0.0",
-		"typescript": "7.0.2",
-		"vitest": "4.1.10"
-	}
-}

package/src/cms/storageHelpers.ts

@@ -1,92 +0,0 @@
-import type {
-    CmsEntry,
-    CmsEntryUniqueValue,
-    CmsEntryValues,
-    CmsModel,
-    CmsModelField,
-    StorageOperationsCmsModel
-} from "@webiny/api-headless-cms/types/index.js";
-import type { Container } from "@webiny/di";
-import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
-import { getBaseFieldType } from "@webiny/api-headless-cms/utils/getBaseFieldType.js";
-import type { StorageTransformRegistry } from "@webiny/api-headless-cms/exports/api/cms/storage.js";
-import type { FilterItemFromStorage } from "../filtering/fields/types.js";
-
-/* Creates a lazy-cached getter for the storage representation of a CMS model. */
-export const createStorageModelAccessor = (container: Container) => {
-    let cached: CmsStorageModelProvider.Interface | undefined;
-
-    const getProvider = () => {
-        if (!cached) {
-            cached = container.resolve(CmsStorageModelProvider);
-        }
-        return cached;
-    };
-
-    const getModel = <T extends CmsEntryValues = CmsEntryValues>(
-        model: CmsModel
-    ): StorageOperationsCmsModel<T> => {
-        return getProvider().getModel<T>(model);
-    };
-
-    return { getModel };
-};
-
-/* Creates a fromStorage transform callable for a given model. */
-export const createStorageTransformCallable = (
-    storageTransformRegistry: StorageTransformRegistry.Interface,
-    model: StorageOperationsCmsModel
-): FilterItemFromStorage => {
-    return async (field: CmsModelField, value: unknown) => {
-        const fieldType = getBaseFieldType(field);
-        const storageTransform = storageTransformRegistry.get(fieldType);
-
-        if (!storageTransform) {
-            return value;
-        }
-
-        const result = await storageTransform.fromStorage({
-            model,
-            field,
-            value,
-            getStorageTransform(ft: string) {
-                return storageTransformRegistry.get(ft) || storageTransformRegistry.get("*")!;
-            }
-        });
-
-        return result;
-    };
-};
-
-/* Aggregates unique values for a given field across a list of CMS entries. */
-export const aggregateUniqueFieldValues = <T extends CmsEntryValues = CmsEntryValues>(
-    items: CmsEntry<T>[],
-    fieldId: string
-): CmsEntryUniqueValue[] => {
-    const result: Record<string, CmsEntryUniqueValue> = {};
-
-    for (const item of items) {
-        const fieldValue = item.values[fieldId] as string[] | string | undefined;
-
-        if (fieldValue == null) {
-            continue;
-        }
-
-        const values = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
-
-        if (values.length === 0) {
-            continue;
-        }
-
-        for (const value of values) {
-            result[value] = {
-                value,
-                count: (result[value]?.count || 0) + 1
-            };
-        }
-    }
-
-    return Object.values(result)
-        .sort((a, b) => (a.value > b.value ? 1 : b.value > a.value ? -1 : 0))
-        .sort((a, b) => b.count - a.count);
-};

package/src/features/FilterRegistriesFeature.ts

@@ -1,40 +0,0 @@
-import { createFeature } from "@webiny/feature/api/index.js";
-import { FieldFilterPathRegistry } from "./fieldFilterPath/abstractions.js";
-import { FieldFilterValueTransformRegistry } from "./fieldFilterValueTransform/abstractions.js";
-import { FieldFilterCreateRegistry } from "./fieldFilterCreate/abstractions.js";
-import { FieldSortingRegistry } from "./fieldSorting/abstractions.js";
-import { FieldFilterPathRegistryImpl } from "./fieldFilterPath/FieldFilterPathRegistry.js";
-import { FieldFilterValueTransformRegistryImpl } from "./fieldFilterValueTransform/FieldFilterValueTransformRegistry.js";
-import { FieldFilterCreateRegistryImpl } from "./fieldFilterCreate/FieldFilterCreateRegistry.js";
-import { FieldSortingRegistryImpl } from "./fieldSorting/FieldSortingRegistry.js";
-import { createPlainObjectPathHandler } from "../handlers/plainObjectPathHandler.js";
-import { createLocationFolderIdPathHandler } from "../handlers/locationFolderIdPathHandler.js";
-import { createDatetimeTransformHandler } from "../handlers/datetimeTransformHandler.js";
-import { createDefaultFilterCreateHandler } from "../handlers/defaultFilterCreateHandler.js";
-import { createRefFilterCreateHandler } from "../handlers/refFilterCreateHandler.js";
-import { createObjectFilterCreateHandler } from "../handlers/objectFilterCreateHandler.js";
-import { createSearchableJsonFilterCreateHandler } from "../handlers/searchableJsonFilterCreateHandler.js";
-
-export const FilterRegistriesFeature = createFeature({
-    name: "cms.storage.filterRegistries",
-    register: container => {
-        const pathRegistry = new FieldFilterPathRegistryImpl();
-        pathRegistry.register("plainObject", createPlainObjectPathHandler());
-        pathRegistry.register("text", createLocationFolderIdPathHandler());
-        container.registerInstance(FieldFilterPathRegistry, pathRegistry);
-
-        const transformRegistry = new FieldFilterValueTransformRegistryImpl();
-        transformRegistry.register("datetime", createDatetimeTransformHandler());
-        container.registerInstance(FieldFilterValueTransformRegistry, transformRegistry);
-
-        const filterCreateRegistry = new FieldFilterCreateRegistryImpl();
-        filterCreateRegistry.register("*", createDefaultFilterCreateHandler());
-        filterCreateRegistry.register("ref", createRefFilterCreateHandler());
-        filterCreateRegistry.register("object", createObjectFilterCreateHandler());
-        filterCreateRegistry.register("searchable-json", createSearchableJsonFilterCreateHandler());
-        container.registerInstance(FieldFilterCreateRegistry, filterCreateRegistry);
-
-        const sortingRegistry = new FieldSortingRegistryImpl();
-        container.registerInstance(FieldSortingRegistry, sortingRegistry);
-    }
-});

package/src/features/fieldFilterCreate/FieldFilterCreateRegistry.ts

@@ -1,25 +0,0 @@
-import WebinyError from "@webiny/error";
-import type { FieldFilterCreateRegistry } from "./abstractions.js";
-
-export class FieldFilterCreateRegistryImpl implements FieldFilterCreateRegistry.Interface {
-    private readonly handlers = new Map<string, FieldFilterCreateRegistry.Handler>();
-
-    public register(fieldType: string, handler: FieldFilterCreateRegistry.Handler): void {
-        this.handlers.set(fieldType, handler);
-    }
-
-    public get(fieldType: string): FieldFilterCreateRegistry.Handler | undefined {
-        return this.handlers.get(fieldType);
-    }
-
-    public getDefault(): FieldFilterCreateRegistry.Handler {
-        const handler = this.handlers.get("*");
-        if (!handler) {
-            throw new WebinyError(
-                "No default filter create handler registered.",
-                "MISSING_DEFAULT_HANDLER"
-            );
-        }
-        return handler;
-    }
-}

package/src/features/fieldFilterCreate/abstractions.ts

@@ -1,51 +0,0 @@
-import { Abstraction } from "@webiny/di";
-import type { Field } from "../../filtering/fields/types.js";
-import type { ValueFilterRegistry } from "@webiny/db-utils";
-import type { FieldFilterValueTransformRegistry } from "../fieldFilterValueTransform/abstractions.js";
-
-export interface IFieldFilterCreateResult {
-    field: Field;
-    path: string;
-    fieldPathId: string;
-    filter: ValueFilterRegistry.Filter;
-    negate: boolean;
-    compareValue: any;
-    transformValue: <I = any, O = any>(value: I) => O;
-}
-
-export interface IFieldFilterCreateParams<T = any> {
-    key: string;
-    value: T;
-    field: Field;
-    fields: Record<string, Field>;
-    operation: string;
-    valueFilterRegistry: ValueFilterRegistry.Interface;
-    transformRegistry: FieldFilterValueTransformRegistry.Interface;
-    getHandler: (fieldType: string) => IFieldFilterCreateHandler;
-    negate: boolean;
-    compareValue: any;
-    transformValue: <I = any, O = any>(value: I) => O;
-}
-
-export interface IFieldFilterCreateHandler {
-    create(
-        params: IFieldFilterCreateParams
-    ): null | IFieldFilterCreateResult | IFieldFilterCreateResult[];
-}
-
-export interface IFieldFilterCreateRegistry {
-    register(fieldType: string, handler: IFieldFilterCreateHandler): void;
-    get(fieldType: string): IFieldFilterCreateHandler | undefined;
-    getDefault(): IFieldFilterCreateHandler;
-}
-
-export const FieldFilterCreateRegistry = new Abstraction<IFieldFilterCreateRegistry>(
-    "Cms/Storage/FieldFilterCreateRegistry"
-);
-
-export namespace FieldFilterCreateRegistry {
-    export type Interface = IFieldFilterCreateRegistry;
-    export type Handler = IFieldFilterCreateHandler;
-    export type Params = IFieldFilterCreateParams;
-    export type Result = IFieldFilterCreateResult;
-}

package/src/features/fieldFilterPath/FieldFilterPathRegistry.ts

@@ -1,13 +0,0 @@
-import type { FieldFilterPathRegistry } from "./abstractions.js";
-
-export class FieldFilterPathRegistryImpl implements FieldFilterPathRegistry.Interface {
-    private readonly handlers = new Map<string, FieldFilterPathRegistry.Handler>();
-
-    public register(fieldType: string, handler: FieldFilterPathRegistry.Handler): void {
-        this.handlers.set(fieldType, handler);
-    }
-
-    public get(fieldType: string): FieldFilterPathRegistry.Handler | undefined {
-        return this.handlers.get(fieldType);
-    }
-}

package/src/features/fieldFilterPath/abstractions.ts

@@ -1,22 +0,0 @@
-import { Abstraction } from "@webiny/di";
-import type { CmsModelField } from "@webiny/api-headless-cms/types/index.js";
-import type { CreatePathCallableParams } from "../../plugins/CmsEntryFieldFilterPathPlugin.js";
-
-export interface IFieldFilterPathHandler {
-    canUse(field: Pick<CmsModelField, "fieldId" | "type">, parents: string[]): boolean;
-    createPath(params: CreatePathCallableParams): string;
-}
-
-export interface IFieldFilterPathRegistry {
-    register(fieldType: string, handler: IFieldFilterPathHandler): void;
-    get(fieldType: string): IFieldFilterPathHandler | undefined;
-}
-
-export const FieldFilterPathRegistry = new Abstraction<IFieldFilterPathRegistry>(
-    "Cms/Storage/FieldFilterPathRegistry"
-);
-
-export namespace FieldFilterPathRegistry {
-    export type Interface = IFieldFilterPathRegistry;
-    export type Handler = IFieldFilterPathHandler;
-}

package/src/features/fieldFilterValueTransform/FieldFilterValueTransformRegistry.ts

@@ -1,15 +0,0 @@
-import type { FieldFilterValueTransformRegistry } from "./abstractions.js";
-
-export class FieldFilterValueTransformRegistryImpl
-    implements FieldFilterValueTransformRegistry.Interface
-{
-    private readonly handlers = new Map<string, FieldFilterValueTransformRegistry.Handler>();
-
-    public register(fieldType: string, handler: FieldFilterValueTransformRegistry.Handler): void {
-        this.handlers.set(fieldType, handler);
-    }
-
-    public get(fieldType: string): FieldFilterValueTransformRegistry.Handler | undefined {
-        return this.handlers.get(fieldType);
-    }
-}

package/src/features/fieldFilterValueTransform/abstractions.ts

@@ -1,21 +0,0 @@
-import { Abstraction } from "@webiny/di";
-import type { CmsFieldFilterValueTransformParams } from "../../plugins/CmsFieldFilterValueTransformPlugin.js";
-
-export interface IFieldFilterValueTransformHandler {
-    transform(params: CmsFieldFilterValueTransformParams): any;
-}
-
-export interface IFieldFilterValueTransformRegistry {
-    register(fieldType: string, handler: IFieldFilterValueTransformHandler): void;
-    get(fieldType: string): IFieldFilterValueTransformHandler | undefined;
-}
-
-export const FieldFilterValueTransformRegistry =
-    new Abstraction<IFieldFilterValueTransformRegistry>(
-        "Cms/Storage/FieldFilterValueTransformRegistry"
-    );
-
-export namespace FieldFilterValueTransformRegistry {
-    export type Interface = IFieldFilterValueTransformRegistry;
-    export type Handler = IFieldFilterValueTransformHandler;
-}

package/src/features/fieldSorting/FieldSortingRegistry.ts

@@ -1,20 +0,0 @@
-import type { FieldSortingRegistry } from "./abstractions.js";
-
-export class FieldSortingRegistryImpl implements FieldSortingRegistry.Interface {
-    private readonly handlers: FieldSortingRegistry.Handler[] = [];
-
-    public register(handler: FieldSortingRegistry.Handler): void {
-        this.handlers.push(handler);
-    }
-
-    public find(
-        params: FieldSortingRegistry.CanUseParams
-    ): FieldSortingRegistry.Handler | undefined {
-        for (let i = this.handlers.length - 1; i >= 0; i--) {
-            if (this.handlers[i].canUse(params)) {
-                return this.handlers[i];
-            }
-        }
-        return undefined;
-    }
-}