@webiny/api-headless-cms 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/features/storage/fields/CompressedTextStorageTransform.js

@@ -0,0 +1,38 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+import { TextFieldTypes } from "../../modelBuilder/index.js";
+class CompressedTextStorageTransformImpl {
+    constructor(compressionHandler){
+        this.compressionHandler = compressionHandler;
+        this.fieldType = TextFieldTypes.COMPRESSED;
+    }
+    async fromStorage(params) {
+        const { value } = params;
+        if ("string" != typeof value) return value;
+        if (!value.includes("compression")) return value;
+        try {
+            const parsed = JSON.parse(value);
+            return await this.compressionHandler.decompress(parsed);
+        } catch  {
+            return value;
+        }
+    }
+    async toStorage(params) {
+        const { value } = params;
+        if ("string" != typeof value) return value;
+        try {
+            return JSON.stringify(await this.compressionHandler.compress(value));
+        } catch  {
+            return value;
+        }
+    }
+}
+const CompressedTextStorageTransform = StorageTransform.createImplementation({
+    implementation: CompressedTextStorageTransformImpl,
+    dependencies: [
+        CompressionHandler
+    ]
+});
+export { CompressedTextStorageTransform };
+
+//# sourceMappingURL=CompressedTextStorageTransform.js.map

package/features/storage/fields/CompressedTextStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/CompressedTextStorageTransform.js","sources":["../../../../src/features/storage/fields/CompressedTextStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\nimport { TextFieldTypes } from \"~/features/modelBuilder/index.js\";\n\nclass CompressedTextStorageTransformImpl implements StorageTransform.Interface<string, string> {\n    public readonly fieldType = TextFieldTypes.COMPRESSED;\n\n    public constructor(private readonly compressionHandler: CompressionHandler.Interface) {}\n\n    public async fromStorage(\n        params: StorageTransform.FromStorageParams<unknown, string>\n    ): StorageTransform.FromStorageResponse<string> {\n        const { value } = params;\n        if (typeof value !== \"string\") {\n            return value as string;\n        } else if (!value.includes(\"compression\")) {\n            return value;\n        }\n        try {\n            const parsed = JSON.parse(value);\n            return await this.compressionHandler.decompress<string>(parsed);\n        } catch {\n            return value;\n        }\n    }\n\n    public async toStorage(\n        params: StorageTransform.ToStorageParams<unknown, string>\n    ): StorageTransform.ToStorageResponse<string> {\n        const { value } = params;\n        if (typeof value !== \"string\") {\n            return value as string;\n        }\n\n        try {\n            return JSON.stringify(await this.compressionHandler.compress(value));\n        } catch {\n            return value;\n        }\n    }\n}\n\nexport const CompressedTextStorageTransform = StorageTransform.createImplementation({\n    implementation: CompressedTextStorageTransformImpl,\n    dependencies: [CompressionHandler]\n});\n"],"names":["CompressedTextStorageTransformImpl","compressionHandler","TextFieldTypes","params","value","parsed","JSON","CompressedTextStorageTransform","StorageTransform","CompressionHandler"],"mappings":";;;AAIA,MAAMA;IAGF,YAAoCC,kBAAgD,CAAE;aAAlDA,kBAAkB,GAAlBA;aAFpB,SAAS,GAAGC,eAAe,UAAU;IAEkC;IAEvF,MAAa,YACTC,MAA2D,EACf;QAC5C,MAAM,EAAEC,KAAK,EAAE,GAAGD;QAClB,IAAI,AAAiB,YAAjB,OAAOC,OACP,OAAOA;QACJ,IAAI,CAACA,MAAM,QAAQ,CAAC,gBACvB,OAAOA;QAEX,IAAI;YACA,MAAMC,SAASC,KAAK,KAAK,CAACF;YAC1B,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAASC;QAC5D,EAAE,OAAM;YACJ,OAAOD;QACX;IACJ;IAEA,MAAa,UACTD,MAAyD,EACf;QAC1C,MAAM,EAAEC,KAAK,EAAE,GAAGD;QAClB,IAAI,AAAiB,YAAjB,OAAOC,OACP,OAAOA;QAGX,IAAI;YACA,OAAOE,KAAK,SAAS,CAAC,MAAM,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAACF;QACjE,EAAE,OAAM;YACJ,OAAOA;QACX;IACJ;AACJ;AAEO,MAAMG,iCAAiCC,iBAAiB,oBAAoB,CAAC;IAChF,gBAAgBR;IAChB,cAAc;QAACS;KAAmB;AACtC"}

package/features/storage/fields/DateStorageTransform.d.ts

@@ -0,0 +1,10 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+declare class DateStorageTransformImpl implements StorageTransform.Interface {
+    readonly fieldType = "datetime";
+    toStorage(params: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+    fromStorage(params: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+}
+export declare const DateStorageTransform: typeof DateStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/DateStorageTransform.js

@@ -0,0 +1,81 @@
+import error from "@webiny/error";
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+const excludeTypes = [
+    "time",
+    "dateTimeWithTimezone"
+];
+const convertFromStorage = (value)=>{
+    if (!value) return null === value ? null : void 0;
+    try {
+        const output = new Date(value);
+        if (isNaN(output.getTime())) {
+            if ("true" !== process.env.DEBUG) return null;
+            console.warn(`Could not transform "${value}" to date.`);
+            return null;
+        }
+        return output;
+    } catch  {
+        if ("true" !== process.env.DEBUG) return null;
+        console.warn(`Could not transform "${value}" from storage for date field type.`);
+        return null;
+    }
+};
+const convertValueToStorage = (field, value)=>{
+    if (value instanceof Date || value?.toISOString) return value.toISOString();
+    if ("string" == typeof value) return value;
+    throw new error("Error converting value to a storage type.", "TO_STORAGE_ERROR", {
+        value: value,
+        fieldId: field.fieldId,
+        storageId: field.storageId
+    });
+};
+class DateStorageTransformImpl {
+    async toStorage(params) {
+        const { value, field } = params;
+        const { type } = field.settings || {};
+        if (!value || !type || excludeTypes.includes(type)) return value;
+        if (field.list) {
+            const list = value;
+            const results = [];
+            for (const input of list){
+                if (!input) continue;
+                const output = convertValueToStorage(field, input);
+                if (output) results.push(output);
+            }
+            return results;
+        }
+        return convertValueToStorage(field, value);
+    }
+    async fromStorage(params) {
+        const { value, field } = params;
+        const { type } = field.settings || {};
+        if (!value || !type || excludeTypes.includes(type)) return value;
+        if (field.list) {
+            if (!Array.isArray(value)) return [];
+            const list = value;
+            const results = [];
+            for (const input of list){
+                if (input instanceof Date) {
+                    if (isNaN(input.getTime())) continue;
+                    results.push(input);
+                    continue;
+                }
+                if (!input || "object" == typeof input && 0 === Object.keys(input).length) continue;
+                const output = convertFromStorage(input);
+                if (output) results.push(output);
+            }
+            return results;
+        }
+        return convertFromStorage(value);
+    }
+    constructor(){
+        this.fieldType = "datetime";
+    }
+}
+const DateStorageTransform = StorageTransform.createImplementation({
+    implementation: DateStorageTransformImpl,
+    dependencies: []
+});
+export { DateStorageTransform };
+
+//# sourceMappingURL=DateStorageTransform.js.map

package/features/storage/fields/DateStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/DateStorageTransform.js","sources":["../../../../src/features/storage/fields/DateStorageTransform.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsModelField } from \"~/types/index.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport { StorageTransform } from \"../abstractions/StorageTransform.js\";\n\nconst excludeTypes = [\"time\", \"dateTimeWithTimezone\"];\n\nconst convertFromStorage = (value: unknown): Date | unknown => {\n    if (!value) {\n        return value === null ? null : undefined;\n    }\n    try {\n        const output = new Date(value as string);\n        if (isNaN(output.getTime())) {\n            if (process.env.DEBUG !== \"true\") {\n                return null;\n            }\n            console.warn(`Could not transform \"${value}\" to date.`);\n            return null;\n        }\n        return output;\n    } catch {\n        if (process.env.DEBUG !== \"true\") {\n            return null;\n        }\n        console.warn(`Could not transform \"${value}\" from storage for date field type.`);\n        return null;\n    }\n};\n\nconst convertValueToStorage = (field: CmsModelField, value: Date | string | unknown): string => {\n    if (value instanceof Date || (value as GenericRecord)?.toISOString) {\n        return (value as Date).toISOString();\n    } else if (typeof value === \"string\") {\n        return value as string;\n    }\n    throw new WebinyError(\"Error converting value to a storage type.\", \"TO_STORAGE_ERROR\", {\n        value: value,\n        fieldId: field.fieldId,\n        storageId: field.storageId\n    });\n};\n\nclass DateStorageTransformImpl implements StorageTransform.Interface {\n    public readonly fieldType = \"datetime\";\n\n    public async toStorage(\n        params: StorageTransform.ToStorageParams\n    ): StorageTransform.ToStorageResponse {\n        const { value, field } = params;\n        const { type } = field.settings || {};\n        if (!value || !type || excludeTypes.includes(type)) {\n            return value;\n        }\n        if (field.list) {\n            const list = value as (string | Date | null | undefined)[];\n            const results: string[] = [];\n            for (const input of list) {\n                if (!input) {\n                    continue;\n                }\n                const output = convertValueToStorage(field, input);\n                if (!output) {\n                    continue;\n                }\n                results.push(output);\n            }\n            return results;\n        }\n        return convertValueToStorage(field, value);\n    }\n\n    public async fromStorage(\n        params: StorageTransform.FromStorageParams\n    ): StorageTransform.FromStorageResponse {\n        const { value, field } = params;\n        const { type } = field.settings || {};\n        if (!value || !type || excludeTypes.includes(type)) {\n            return value;\n        } else if (field.list) {\n            if (!Array.isArray(value)) {\n                return [];\n            }\n            const list = value as unknown[];\n            const results: (Date | unknown)[] = [];\n            for (const input of list) {\n                if (input instanceof Date) {\n                    if (isNaN(input.getTime())) {\n                        continue;\n                    }\n                    results.push(input);\n                    continue;\n                } else if (\n                    !input ||\n                    (typeof input === \"object\" && Object.keys(input).length === 0)\n                ) {\n                    continue;\n                }\n                const output = convertFromStorage(input);\n                if (!output) {\n                    continue;\n                }\n                results.push(output);\n            }\n            return results;\n        }\n        return convertFromStorage(value);\n    }\n}\n\nexport const DateStorageTransform = StorageTransform.createImplementation({\n    implementation: DateStorageTransformImpl,\n    dependencies: []\n});\n"],"names":["excludeTypes","convertFromStorage","value","undefined","output","Date","isNaN","process","console","convertValueToStorage","field","WebinyError","DateStorageTransformImpl","params","type","list","results","input","Array","Object","DateStorageTransform","StorageTransform"],"mappings":";;AAKA,MAAMA,eAAe;IAAC;IAAQ;CAAuB;AAErD,MAAMC,qBAAqB,CAACC;IACxB,IAAI,CAACA,OACD,OAAOA,AAAU,SAAVA,QAAiB,OAAOC;IAEnC,IAAI;QACA,MAAMC,SAAS,IAAIC,KAAKH;QACxB,IAAII,MAAMF,OAAO,OAAO,KAAK;YACzB,IAAIG,AAAsB,WAAtBA,QAAQ,GAAG,CAAC,KAAK,EACjB,OAAO;YAEXC,QAAQ,IAAI,CAAC,CAAC,qBAAqB,EAAEN,MAAM,UAAU,CAAC;YACtD,OAAO;QACX;QACA,OAAOE;IACX,EAAE,OAAM;QACJ,IAAIG,AAAsB,WAAtBA,QAAQ,GAAG,CAAC,KAAK,EACjB,OAAO;QAEXC,QAAQ,IAAI,CAAC,CAAC,qBAAqB,EAAEN,MAAM,mCAAmC,CAAC;QAC/E,OAAO;IACX;AACJ;AAEA,MAAMO,wBAAwB,CAACC,OAAsBR;IACjD,IAAIA,iBAAiBG,QAASH,OAAyB,aACnD,OAAQA,MAAe,WAAW;IAC/B,IAAI,AAAiB,YAAjB,OAAOA,OACd,OAAOA;IAEX,MAAM,IAAIS,MAAY,6CAA6C,oBAAoB;QACnF,OAAOT;QACP,SAASQ,MAAM,OAAO;QACtB,WAAWA,MAAM,SAAS;IAC9B;AACJ;AAEA,MAAME;IAGF,MAAa,UACTC,MAAwC,EACN;QAClC,MAAM,EAAEX,KAAK,EAAEQ,KAAK,EAAE,GAAGG;QACzB,MAAM,EAAEC,IAAI,EAAE,GAAGJ,MAAM,QAAQ,IAAI,CAAC;QACpC,IAAI,CAACR,SAAS,CAACY,QAAQd,aAAa,QAAQ,CAACc,OACzC,OAAOZ;QAEX,IAAIQ,MAAM,IAAI,EAAE;YACZ,MAAMK,OAAOb;YACb,MAAMc,UAAoB,EAAE;YAC5B,KAAK,MAAMC,SAASF,KAAM;gBACtB,IAAI,CAACE,OACD;gBAEJ,MAAMb,SAASK,sBAAsBC,OAAOO;gBAC5C,IAAKb,QAGLY,QAAQ,IAAI,CAACZ;YACjB;YACA,OAAOY;QACX;QACA,OAAOP,sBAAsBC,OAAOR;IACxC;IAEA,MAAa,YACTW,MAA0C,EACN;QACpC,MAAM,EAAEX,KAAK,EAAEQ,KAAK,EAAE,GAAGG;QACzB,MAAM,EAAEC,IAAI,EAAE,GAAGJ,MAAM,QAAQ,IAAI,CAAC;QACpC,IAAI,CAACR,SAAS,CAACY,QAAQd,aAAa,QAAQ,CAACc,OACzC,OAAOZ;QACJ,IAAIQ,MAAM,IAAI,EAAE;YACnB,IAAI,CAACQ,MAAM,OAAO,CAAChB,QACf,OAAO,EAAE;YAEb,MAAMa,OAAOb;YACb,MAAMc,UAA8B,EAAE;YACtC,KAAK,MAAMC,SAASF,KAAM;gBACtB,IAAIE,iBAAiBZ,MAAM;oBACvB,IAAIC,MAAMW,MAAM,OAAO,KACnB;oBAEJD,QAAQ,IAAI,CAACC;oBACb;gBACJ;gBAAO,IACH,CAACA,SACA,AAAiB,YAAjB,OAAOA,SAAsBE,AAA8B,MAA9BA,OAAO,IAAI,CAACF,OAAO,MAAM,EAEvD;gBAEJ,MAAMb,SAASH,mBAAmBgB;gBAClC,IAAKb,QAGLY,QAAQ,IAAI,CAACZ;YACjB;YACA,OAAOY;QACX;QACA,OAAOf,mBAAmBC;IAC9B;;aA/DgB,SAAS,GAAG;;AAgEhC;AAEO,MAAMkB,uBAAuBC,iBAAiB,oBAAoB,CAAC;IACtE,gBAAgBT;IAChB,cAAc,EAAE;AACpB"}

package/features/storage/fields/DefaultStorageTransform.d.ts

@@ -0,0 +1,10 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+declare class DefaultStorageTransformImpl implements StorageTransform.Interface {
+    readonly fieldType = "*";
+    fromStorage({ value }: StorageTransform.FromStorageParams): Promise<any>;
+    toStorage({ value }: StorageTransform.ToStorageParams): Promise<any>;
+}
+export declare const DefaultStorageTransform: typeof DefaultStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/DefaultStorageTransform.js

@@ -0,0 +1,19 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+class DefaultStorageTransformImpl {
+    async fromStorage({ value }) {
+        return value;
+    }
+    async toStorage({ value }) {
+        return value;
+    }
+    constructor(){
+        this.fieldType = "*";
+    }
+}
+const DefaultStorageTransform = StorageTransform.createImplementation({
+    implementation: DefaultStorageTransformImpl,
+    dependencies: []
+});
+export { DefaultStorageTransform };
+
+//# sourceMappingURL=DefaultStorageTransform.js.map

package/features/storage/fields/DefaultStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/DefaultStorageTransform.js","sources":["../../../../src/features/storage/fields/DefaultStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\n\nclass DefaultStorageTransformImpl implements StorageTransform.Interface {\n    public readonly fieldType = \"*\";\n\n    public async fromStorage({ value }: StorageTransform.FromStorageParams) {\n        return value;\n    }\n\n    public async toStorage({ value }: StorageTransform.ToStorageParams) {\n        return value;\n    }\n}\n\nexport const DefaultStorageTransform = StorageTransform.createImplementation({\n    implementation: DefaultStorageTransformImpl,\n    dependencies: []\n});\n"],"names":["DefaultStorageTransformImpl","value","DefaultStorageTransform","StorageTransform"],"mappings":";AAEA,MAAMA;IAGF,MAAa,YAAY,EAAEC,KAAK,EAAsC,EAAE;QACpE,OAAOA;IACX;IAEA,MAAa,UAAU,EAAEA,KAAK,EAAoC,EAAE;QAChE,OAAOA;IACX;;aARgB,SAAS,GAAG;;AAShC;AAEO,MAAMC,0BAA0BC,iBAAiB,oBAAoB,CAAC;IACzE,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/features/storage/fields/DynamicZoneStorageTransform.d.ts

@@ -0,0 +1,10 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+declare class DynamicZoneStorageTransformImpl implements StorageTransform.Interface {
+    readonly fieldType = "dynamicZone";
+    toStorage(params: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+    fromStorage(params: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+}
+export declare const DynamicZoneStorageTransform: typeof DynamicZoneStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/DynamicZoneStorageTransform.js

@@ -0,0 +1,105 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import p_reduce from "p-reduce";
+const processToStorage = async (params)=>{
+    const { model, field: parentField, value: input, getStorageTransform } = params;
+    const output = structuredClone(input);
+    if (!output._templateId) return output;
+    const template = parentField.settings.templates.find((t)=>t.id === output._templateId);
+    if (!template || !template.fields.length) return output;
+    return await p_reduce(template.fields, async (values, field)=>{
+        const value = values[field.fieldId];
+        if (!value) {
+            values[field.fieldId] = value;
+            return values;
+        }
+        const storageTransform = getStorageTransform(field.type);
+        if (!storageTransform) {
+            console.error(`Missing storage transform for field type "${field.type}".`);
+            delete values[field.fieldId];
+            return values;
+        }
+        values[field.fieldId] = await storageTransform.toStorage({
+            getStorageTransform,
+            model,
+            field,
+            value
+        });
+        return values;
+    }, output);
+};
+const processFromStorage = async (params)=>{
+    const { model, field: parentField, value: input, getStorageTransform } = params;
+    const output = structuredClone(input);
+    if (!output._templateId) return output;
+    const template = parentField.settings.templates.find((t)=>t.id === output._templateId);
+    if (!template || !template.fields.length) return output;
+    return await p_reduce(template.fields, async (values, field)=>{
+        const value = values[field.fieldId];
+        if (!value) return values;
+        const storageTransform = getStorageTransform(field.type);
+        if (!storageTransform) {
+            console.error(`Missing storage transform for field type "${field.type}".`);
+            delete values[field.fieldId];
+            return values;
+        }
+        values[field.fieldId] = await storageTransform.fromStorage({
+            getStorageTransform,
+            model,
+            field,
+            value
+        });
+        return values;
+    }, output);
+};
+class DynamicZoneStorageTransformImpl {
+    async toStorage(params) {
+        const { value: input, field, model, getStorageTransform } = params;
+        if (!input) return input;
+        if (field.list) {
+            if (!Array.isArray(input)) return input;
+            const values = input;
+            return Promise.all(values.map(async (value)=>await processToStorage({
+                    model,
+                    field: field,
+                    value,
+                    getStorageTransform
+                })));
+        }
+        return await processToStorage({
+            model,
+            field: field,
+            value: input,
+            getStorageTransform
+        });
+    }
+    async fromStorage(params) {
+        const { value: input, field, model, getStorageTransform } = params;
+        if (!input) return input;
+        if (field.list) {
+            if (!Array.isArray(input)) return input;
+            const values = input;
+            return await Promise.all(values.map(async (value)=>await processFromStorage({
+                    model,
+                    field: field,
+                    value,
+                    getStorageTransform
+                })));
+        }
+        return await processFromStorage({
+            model,
+            field: field,
+            value: input,
+            getStorageTransform
+        });
+    }
+    constructor(){
+        this.fieldType = "dynamicZone";
+    }
+}
+const DynamicZoneStorageTransform = StorageTransform.createImplementation({
+    implementation: DynamicZoneStorageTransformImpl,
+    dependencies: []
+});
+export { DynamicZoneStorageTransform };
+
+//# sourceMappingURL=DynamicZoneStorageTransform.js.map

package/features/storage/fields/DynamicZoneStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/DynamicZoneStorageTransform.js","sources":["../../../../src/features/storage/fields/DynamicZoneStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { CmsModel, CmsModelDynamicZoneField } from \"~/types/index.js\";\nimport pReduce from \"p-reduce\";\n\ninterface IProcessParams {\n    model: CmsModel;\n    field: CmsModelDynamicZoneField;\n    value: GenericRecord;\n    getStorageTransform: (fieldType: string) => StorageTransform.Interface;\n}\n\nconst processToStorage = async (params: IProcessParams): Promise<GenericRecord> => {\n    const { model, field: parentField, value: input, getStorageTransform } = params;\n\n    const output: GenericRecord = structuredClone(input);\n\n    if (!output._templateId) {\n        return output;\n    }\n    const template = parentField.settings.templates.find(t => t.id === output._templateId);\n    if (!template || !template.fields.length) {\n        return output;\n    }\n\n    return await pReduce(\n        template.fields,\n        async (values, field) => {\n            const value = values[field.fieldId];\n\n            if (!value) {\n                values[field.fieldId] = value;\n                return values;\n            }\n            const storageTransform = getStorageTransform(field.type);\n            if (!storageTransform) {\n                console.error(`Missing storage transform for field type \"${field.type}\".`);\n                delete values[field.fieldId];\n                return values;\n            }\n            values[field.fieldId] = await storageTransform.toStorage({\n                getStorageTransform,\n                model,\n                field,\n                value\n            });\n\n            return values;\n        },\n        output\n    );\n};\n\nconst processFromStorage = async (params: IProcessParams): Promise<GenericRecord> => {\n    const { model, field: parentField, value: input, getStorageTransform } = params;\n\n    const output: GenericRecord = structuredClone(input);\n\n    if (!output._templateId) {\n        return output;\n    }\n    const template = parentField.settings.templates.find(t => t.id === output._templateId);\n    if (!template || !template.fields.length) {\n        return output;\n    }\n\n    return await pReduce(\n        template.fields,\n        async (values, field) => {\n            const value = values[field.fieldId];\n\n            if (!value) {\n                return values;\n            }\n            const storageTransform = getStorageTransform(field.type);\n            if (!storageTransform) {\n                console.error(`Missing storage transform for field type \"${field.type}\".`);\n                delete values[field.fieldId];\n                return values;\n            }\n            values[field.fieldId] = await storageTransform.fromStorage({\n                getStorageTransform,\n                model,\n                field,\n                value\n            });\n\n            return values;\n        },\n        output\n    );\n};\n\nclass DynamicZoneStorageTransformImpl implements StorageTransform.Interface {\n    public readonly fieldType = \"dynamicZone\";\n\n    public async toStorage(\n        params: StorageTransform.ToStorageParams\n    ): StorageTransform.ToStorageResponse {\n        const { value: input, field, model, getStorageTransform } = params;\n        if (!input) {\n            return input;\n        } else if (field.list) {\n            if (!Array.isArray(input)) {\n                return input;\n            }\n            const values = input as GenericRecord[];\n            return Promise.all(\n                values.map(async value => {\n                    return await processToStorage({\n                        model,\n                        field: field as CmsModelDynamicZoneField,\n                        value,\n                        getStorageTransform\n                    });\n                })\n            );\n        }\n        return await processToStorage({\n            model,\n            field: field as CmsModelDynamicZoneField,\n            value: input,\n            getStorageTransform\n        });\n    }\n\n    public async fromStorage(\n        params: StorageTransform.FromStorageParams\n    ): StorageTransform.FromStorageResponse {\n        const { value: input, field, model, getStorageTransform } = params;\n        if (!input) {\n            return input;\n        } else if (field.list) {\n            if (!Array.isArray(input)) {\n                return input;\n            }\n            const values = input as GenericRecord[];\n\n            return await Promise.all(\n                values.map(async value => {\n                    return await processFromStorage({\n                        model,\n                        field: field as CmsModelDynamicZoneField,\n                        value,\n                        getStorageTransform\n                    });\n                })\n            );\n        }\n        return await processFromStorage({\n            model,\n            field: field as CmsModelDynamicZoneField,\n            value: input,\n            getStorageTransform\n        });\n    }\n}\n\nexport const DynamicZoneStorageTransform = StorageTransform.createImplementation({\n    implementation: DynamicZoneStorageTransformImpl,\n    dependencies: []\n});\n"],"names":["processToStorage","params","model","parentField","input","getStorageTransform","output","structuredClone","template","t","pReduce","values","field","value","storageTransform","console","processFromStorage","DynamicZoneStorageTransformImpl","Array","Promise","DynamicZoneStorageTransform","StorageTransform"],"mappings":"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"}

package/features/storage/fields/EncryptedTextStorageTransform.d.ts

@@ -0,0 +1,14 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { Encryption } from "@webiny/api-core/features/encryption/index.js";
+import { TextFieldTypes } from "../../../features/modelBuilder/index.js";
+declare class EncryptedTextStorageTransformImpl implements StorageTransform.Interface<string, string> {
+    private readonly encryption;
+    readonly fieldType = TextFieldTypes.ENCRYPTED;
+    constructor(encryption: Encryption.Interface);
+    fromStorage(params: StorageTransform.FromStorageParams<unknown, string>): StorageTransform.FromStorageResponse<string>;
+    toStorage(params: StorageTransform.ToStorageParams<unknown, string>): StorageTransform.ToStorageResponse<string>;
+}
+export declare const EncryptedTextStorageTransform: typeof EncryptedTextStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/EncryptedTextStorageTransform.js

@@ -0,0 +1,36 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { Encryption } from "@webiny/api-core/features/encryption/index.js";
+import { TextFieldTypes } from "../../modelBuilder/index.js";
+class EncryptedTextStorageTransformImpl {
+    constructor(encryption){
+        this.encryption = encryption;
+        this.fieldType = TextFieldTypes.ENCRYPTED;
+    }
+    async fromStorage(params) {
+        const { value } = params;
+        if (!value || "string" != typeof value || 0 === value.length) return value;
+        try {
+            return await this.encryption.decrypt(value);
+        } catch  {
+            return value;
+        }
+    }
+    async toStorage(params) {
+        const { value } = params;
+        if (!value || "string" != typeof value || 0 === value.length) return value;
+        try {
+            return await this.encryption.encrypt(value);
+        } catch  {
+            return value;
+        }
+    }
+}
+const EncryptedTextStorageTransform = StorageTransform.createImplementation({
+    implementation: EncryptedTextStorageTransformImpl,
+    dependencies: [
+        Encryption
+    ]
+});
+export { EncryptedTextStorageTransform };
+
+//# sourceMappingURL=EncryptedTextStorageTransform.js.map

package/features/storage/fields/EncryptedTextStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/EncryptedTextStorageTransform.js","sources":["../../../../src/features/storage/fields/EncryptedTextStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { Encryption } from \"@webiny/api-core/features/encryption/index.js\";\nimport { TextFieldTypes } from \"~/features/modelBuilder/index.js\";\n\nclass EncryptedTextStorageTransformImpl implements StorageTransform.Interface<string, string> {\n    public readonly fieldType = TextFieldTypes.ENCRYPTED;\n\n    public constructor(private readonly encryption: Encryption.Interface) {}\n\n    public async fromStorage(\n        params: StorageTransform.FromStorageParams<unknown, string>\n    ): StorageTransform.FromStorageResponse<string> {\n        const { value } = params;\n        if (!value || typeof value !== \"string\" || value.length === 0) {\n            return value as string;\n        }\n        try {\n            return await this.encryption.decrypt(value);\n        } catch {\n            return value;\n        }\n    }\n\n    public async toStorage(\n        params: StorageTransform.ToStorageParams<unknown, string>\n    ): StorageTransform.ToStorageResponse<string> {\n        const { value } = params;\n        if (!value || typeof value !== \"string\" || value.length === 0) {\n            return value as string;\n        }\n\n        try {\n            return await this.encryption.encrypt(value);\n        } catch {\n            return value;\n        }\n    }\n}\n\nexport const EncryptedTextStorageTransform = StorageTransform.createImplementation({\n    implementation: EncryptedTextStorageTransformImpl,\n    dependencies: [Encryption]\n});\n"],"names":["EncryptedTextStorageTransformImpl","encryption","TextFieldTypes","params","value","EncryptedTextStorageTransform","StorageTransform","Encryption"],"mappings":";;;AAIA,MAAMA;IAGF,YAAoCC,UAAgC,CAAE;aAAlCA,UAAU,GAAVA;aAFpB,SAAS,GAAGC,eAAe,SAAS;IAEmB;IAEvE,MAAa,YACTC,MAA2D,EACf;QAC5C,MAAM,EAAEC,KAAK,EAAE,GAAGD;QAClB,IAAI,CAACC,SAAS,AAAiB,YAAjB,OAAOA,SAAsBA,AAAiB,MAAjBA,MAAM,MAAM,EACnD,OAAOA;QAEX,IAAI;YACA,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;QACzC,EAAE,OAAM;YACJ,OAAOA;QACX;IACJ;IAEA,MAAa,UACTD,MAAyD,EACf;QAC1C,MAAM,EAAEC,KAAK,EAAE,GAAGD;QAClB,IAAI,CAACC,SAAS,AAAiB,YAAjB,OAAOA,SAAsBA,AAAiB,MAAjBA,MAAM,MAAM,EACnD,OAAOA;QAGX,IAAI;YACA,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;QACzC,EAAE,OAAM;YACJ,OAAOA;QACX;IACJ;AACJ;AAEO,MAAMC,gCAAgCC,iBAAiB,oBAAoB,CAAC;IAC/E,gBAAgBN;IAChB,cAAc;QAACO;KAAW;AAC9B"}

package/features/storage/fields/JsonStorageTransform.d.ts

@@ -0,0 +1,13 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+declare class JsonStorageTransformImpl implements StorageTransform.Interface {
+    private readonly compressorHandler;
+    fieldType: string;
+    constructor(compressorHandler: CompressionHandler.Interface);
+    fromStorage({ field, value }: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+    toStorage({ value }: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+}
+export declare const JsonStorageTransform: typeof JsonStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/JsonStorageTransform.js

@@ -0,0 +1,26 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { WebinyError } from "@webiny/error";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+class JsonStorageTransformImpl {
+    constructor(compressorHandler){
+        this.compressorHandler = compressorHandler;
+        this.fieldType = "json";
+    }
+    async fromStorage({ field, value }) {
+        if (!value) return value;
+        if ("object" != typeof value) throw new WebinyError(`JSON value received in "fromStorage" function is not an object in field "${field.storageId}" - ${field.fieldId}.`);
+        return await this.compressorHandler.decompress(value);
+    }
+    async toStorage({ value }) {
+        return await this.compressorHandler.compress(value);
+    }
+}
+const JsonStorageTransform = StorageTransform.createImplementation({
+    implementation: JsonStorageTransformImpl,
+    dependencies: [
+        CompressionHandler
+    ]
+});
+export { JsonStorageTransform };
+
+//# sourceMappingURL=JsonStorageTransform.js.map

package/features/storage/fields/JsonStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/JsonStorageTransform.js","sources":["../../../../src/features/storage/fields/JsonStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { WebinyError } from \"@webiny/error\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\n\nclass JsonStorageTransformImpl implements StorageTransform.Interface {\n    public fieldType = \"json\";\n\n    public constructor(private readonly compressorHandler: CompressionHandler.Interface) {}\n\n    public async fromStorage({\n        field,\n        value\n    }: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse {\n        if (!value) {\n            return value;\n        } else if (typeof value !== \"object\") {\n            throw new WebinyError(\n                `JSON value received in \"fromStorage\" function is not an object in field \"${field.storageId}\" - ${field.fieldId}.`\n            );\n        }\n\n        return await this.compressorHandler.decompress(value);\n    }\n\n    public async toStorage({\n        value\n    }: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse {\n        return await this.compressorHandler.compress(value);\n    }\n}\n\nexport const JsonStorageTransform = StorageTransform.createImplementation({\n    implementation: JsonStorageTransformImpl,\n    dependencies: [CompressionHandler]\n});\n"],"names":["JsonStorageTransformImpl","compressorHandler","field","value","WebinyError","JsonStorageTransform","StorageTransform","CompressionHandler"],"mappings":";;;AAIA,MAAMA;IAGF,YAAoCC,iBAA+C,CAAE;aAAjDA,iBAAiB,GAAjBA;aAF7B,SAAS,GAAG;IAEmE;IAEtF,MAAa,YAAY,EACrBC,KAAK,EACLC,KAAK,EAC4B,EAAwC;QACzE,IAAI,CAACA,OACD,OAAOA;QACJ,IAAI,AAAiB,YAAjB,OAAOA,OACd,MAAM,IAAIC,YACN,CAAC,yEAAyE,EAAEF,MAAM,SAAS,CAAC,IAAI,EAAEA,MAAM,OAAO,CAAC,CAAC,CAAC;QAI1H,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAACC;IACnD;IAEA,MAAa,UAAU,EACnBA,KAAK,EAC0B,EAAsC;QACrE,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAACA;IACjD;AACJ;AAEO,MAAME,uBAAuBC,iBAAiB,oBAAoB,CAAC;IACtE,gBAAgBN;IAChB,cAAc;QAACO;KAAmB;AACtC"}

package/features/storage/fields/LongTextStorageTransform.d.ts

@@ -0,0 +1,18 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+interface StorageValue {
+    compression: string;
+    value: string;
+    isArray?: boolean;
+}
+declare class LongTextStorageTransformImpl implements StorageTransform.Interface<string | string[], StorageValue> {
+    private readonly compressionHandler;
+    readonly fieldType = "long-text";
+    constructor(compressionHandler: CompressionHandler.Interface);
+    fromStorage({ field, value: storageValue }: StorageTransform.FromStorageParams<string | string[], StorageValue>): StorageTransform.FromStorageResponse<string | string[]>;
+    toStorage({ value: initialValue }: StorageTransform.ToStorageParams<string | string[], StorageValue>): StorageTransform.ToStorageResponse<StorageValue>;
+}
+export declare const LongTextStorageTransform: typeof LongTextStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/LongTextStorageTransform.js

@@ -0,0 +1,44 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { WebinyError } from "@webiny/error";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+class LongTextStorageTransformImpl {
+    constructor(compressionHandler){
+        this.compressionHandler = compressionHandler;
+        this.fieldType = "long-text";
+    }
+    async fromStorage({ field, value: storageValue }) {
+        const typeOf = typeof storageValue;
+        if (!storageValue || "string" === typeOf || "number" === typeOf || true === Array.isArray(storageValue)) return storageValue;
+        if ("object" !== typeOf) throw new WebinyError(`LongText value received in "fromStorage" function is not an object in field "${field.storageId}" - ${field.fieldId}.`);
+        try {
+            const sv = storageValue;
+            const result = await this.compressionHandler.decompress(storageValue);
+            if (!sv.isArray) return result;
+            return JSON.parse(result);
+        } catch (ex) {
+            console.log("Error while transforming long-text.");
+            console.log(ex.message);
+            return "";
+        }
+    }
+    async toStorage({ value: initialValue }) {
+        if (initialValue && initialValue.compression) return initialValue;
+        const isArray = Array.isArray(initialValue);
+        const value = isArray ? JSON.stringify(initialValue) : initialValue;
+        const compressed = await this.compressionHandler.compress(value);
+        if (!isArray) return compressed;
+        return {
+            ...compressed,
+            isArray
+        };
+    }
+}
+const LongTextStorageTransform = StorageTransform.createImplementation({
+    implementation: LongTextStorageTransformImpl,
+    dependencies: [
+        CompressionHandler
+    ]
+});
+export { LongTextStorageTransform };
+
+//# sourceMappingURL=LongTextStorageTransform.js.map

package/features/storage/fields/LongTextStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/LongTextStorageTransform.js","sources":["../../../../src/features/storage/fields/LongTextStorageTransform.ts"],"sourcesContent":["import { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { WebinyError } from \"@webiny/error\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\n\ninterface StorageValue {\n    compression: string;\n    value: string;\n    isArray?: boolean;\n}\n\nclass LongTextStorageTransformImpl implements StorageTransform.Interface<\n    string | string[],\n    StorageValue\n> {\n    public readonly fieldType = \"long-text\";\n\n    public constructor(private readonly compressionHandler: CompressionHandler.Interface) {}\n\n    public async fromStorage({\n        field,\n        value: storageValue\n    }: StorageTransform.FromStorageParams<\n        string | string[],\n        StorageValue\n    >): StorageTransform.FromStorageResponse<string | string[]> {\n        const typeOf = typeof storageValue;\n        if (\n            !storageValue ||\n            typeOf === \"string\" ||\n            typeOf === \"number\" ||\n            Array.isArray(storageValue) === true\n        ) {\n            return storageValue as unknown as string | string[];\n        } else if (typeOf !== \"object\") {\n            throw new WebinyError(\n                `LongText value received in \"fromStorage\" function is not an object in field \"${field.storageId}\" - ${field.fieldId}.`\n            );\n        }\n\n        try {\n            const sv = storageValue as unknown as StorageValue;\n            const result = await this.compressionHandler.decompress<string>(storageValue);\n            if (!sv.isArray) {\n                return result;\n            }\n            return JSON.parse(result);\n        } catch (ex) {\n            console.log(\"Error while transforming long-text.\");\n            console.log(ex.message);\n            return \"\";\n        }\n    }\n\n    public async toStorage({\n        value: initialValue\n    }: StorageTransform.ToStorageParams<\n        string | string[],\n        StorageValue\n    >): StorageTransform.ToStorageResponse<StorageValue> {\n        if (initialValue && (initialValue as unknown as StorageValue).compression) {\n            return initialValue as unknown as StorageValue;\n        }\n        const isArray = Array.isArray(initialValue);\n        const value = isArray ? JSON.stringify(initialValue) : initialValue;\n        const compressed = await this.compressionHandler.compress(value);\n\n        if (!isArray) {\n            return compressed as unknown as StorageValue;\n        }\n        return { ...compressed, isArray } as unknown as StorageValue;\n    }\n}\n\nexport const LongTextStorageTransform = StorageTransform.createImplementation({\n    implementation: LongTextStorageTransformImpl,\n    dependencies: [CompressionHandler]\n});\n"],"names":["LongTextStorageTransformImpl","compressionHandler","field","storageValue","typeOf","Array","WebinyError","sv","result","JSON","ex","console","initialValue","isArray","value","compressed","LongTextStorageTransform","StorageTransform","CompressionHandler"],"mappings":";;;AAUA,MAAMA;IAMF,YAAoCC,kBAAgD,CAAE;aAAlDA,kBAAkB,GAAlBA;aAFpB,SAAS,GAAG;IAE2D;IAEvF,MAAa,YAAY,EACrBC,KAAK,EACL,OAAOC,YAAY,EAItB,EAA2D;QACxD,MAAMC,SAAS,OAAOD;QACtB,IACI,CAACA,gBACDC,AAAW,aAAXA,UACAA,AAAW,aAAXA,UACAC,AAAgC,SAAhCA,MAAM,OAAO,CAACF,eAEd,OAAOA;QACJ,IAAIC,AAAW,aAAXA,QACP,MAAM,IAAIE,YACN,CAAC,6EAA6E,EAAEJ,MAAM,SAAS,CAAC,IAAI,EAAEA,MAAM,OAAO,CAAC,CAAC,CAAC;QAI9H,IAAI;YACA,MAAMK,KAAKJ;YACX,MAAMK,SAAS,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAASL;YAChE,IAAI,CAACI,GAAG,OAAO,EACX,OAAOC;YAEX,OAAOC,KAAK,KAAK,CAACD;QACtB,EAAE,OAAOE,IAAI;YACTC,QAAQ,GAAG,CAAC;YACZA,QAAQ,GAAG,CAACD,GAAG,OAAO;YACtB,OAAO;QACX;IACJ;IAEA,MAAa,UAAU,EACnB,OAAOE,YAAY,EAItB,EAAoD;QACjD,IAAIA,gBAAiBA,aAAyC,WAAW,EACrE,OAAOA;QAEX,MAAMC,UAAUR,MAAM,OAAO,CAACO;QAC9B,MAAME,QAAQD,UAAUJ,KAAK,SAAS,CAACG,gBAAgBA;QACvD,MAAMG,aAAa,MAAM,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAACD;QAE1D,IAAI,CAACD,SACD,OAAOE;QAEX,OAAO;YAAE,GAAGA,UAAU;YAAEF;QAAQ;IACpC;AACJ;AAEO,MAAMG,2BAA2BC,iBAAiB,oBAAoB,CAAC;IAC1E,gBAAgBjB;IAChB,cAAc;QAACkB;KAAmB;AACtC"}

package/features/storage/fields/ObjectStorageTransform.d.ts

@@ -0,0 +1,10 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+declare class StorageTransformImpl implements StorageTransform.Interface {
+    readonly fieldType = "object";
+    toStorage(params: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+    fromStorage(params: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+}
+export declare const ObjectStorageTransform: typeof StorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};

package/features/storage/fields/ObjectStorageTransform.js

@@ -0,0 +1,76 @@
+import p_reduce from "p-reduce";
+import p_map from "p-map";
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { getBaseFieldType } from "../../../utils/getBaseFieldType.js";
+const processValue = async (params)=>{
+    const { fields, sourceValue, getStorageTransform, model, operation } = params;
+    return await p_reduce(fields, async (values, field)=>{
+        const baseType = getBaseFieldType(field);
+        const storageTransform = getStorageTransform(baseType);
+        if (!storageTransform) throw new Error(`Missing storage transform for field type "${baseType}".`);
+        const input = sourceValue[field.fieldId];
+        const value = await storageTransform[operation]({
+            model,
+            field,
+            value: input,
+            getStorageTransform
+        });
+        return {
+            ...values,
+            [field.fieldId]: value
+        };
+    }, {});
+};
+class StorageTransformImpl {
+    async toStorage(params) {
+        const { value, field, getStorageTransform, model } = params;
+        if (!value) return null;
+        const fields = field.settings?.fields || [];
+        if (field.list) return await p_map(value, (value)=>processValue({
+                sourceValue: value,
+                getStorageTransform,
+                model,
+                operation: "toStorage",
+                fields
+            }));
+        return await processValue({
+            sourceValue: value,
+            getStorageTransform,
+            model,
+            operation: "toStorage",
+            fields
+        });
+    }
+    async fromStorage(params) {
+        const { field, value: input, getStorageTransform, model } = params;
+        if (!input) return null;
+        const fields = field.settings?.fields || [];
+        if (field.list) {
+            const values = input;
+            return await Promise.all(values.map(async (value)=>await processValue({
+                    sourceValue: value,
+                    getStorageTransform,
+                    model,
+                    operation: "fromStorage",
+                    fields
+                })));
+        }
+        return await processValue({
+            sourceValue: input,
+            getStorageTransform,
+            model,
+            operation: "fromStorage",
+            fields
+        });
+    }
+    constructor(){
+        this.fieldType = "object";
+    }
+}
+const ObjectStorageTransform = StorageTransform.createImplementation({
+    implementation: StorageTransformImpl,
+    dependencies: []
+});
+export { ObjectStorageTransform };
+
+//# sourceMappingURL=ObjectStorageTransform.js.map

package/features/storage/fields/ObjectStorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/fields/ObjectStorageTransform.js","sources":["../../../../src/features/storage/fields/ObjectStorageTransform.ts"],"sourcesContent":["import pReduce from \"p-reduce\";\nimport pMap from \"p-map\";\nimport type { CmsModel, CmsModelField } from \"~/types/index.js\";\nimport { StorageTransform } from \"../abstractions/StorageTransform.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\ninterface ProcessValueParams {\n    fields: CmsModelField[];\n    sourceValue: GenericRecord;\n    getStorageTransform: (fieldType: string) => StorageTransform.Interface;\n    model: CmsModel;\n    operation: \"toStorage\" | \"fromStorage\";\n}\ninterface ProcessValue {\n    (params: ProcessValueParams): Promise<GenericRecord>;\n}\n\nconst processValue: ProcessValue = async params => {\n    const { fields, sourceValue, getStorageTransform, model, operation } = params;\n    return await pReduce(\n        fields,\n        async (values, field) => {\n            const baseType = getBaseFieldType(field);\n            const storageTransform = getStorageTransform(baseType);\n            if (!storageTransform) {\n                throw new Error(`Missing storage transform for field type \"${baseType}\".`);\n            }\n            const input = sourceValue[field.fieldId];\n            const value = await storageTransform[operation]({\n                model,\n                field,\n                value: input,\n                getStorageTransform\n            });\n            return { ...values, [field.fieldId]: value };\n        },\n        {}\n    );\n};\n\nclass StorageTransformImpl implements StorageTransform.Interface {\n    public readonly fieldType = \"object\";\n\n    public async toStorage(\n        params: StorageTransform.ToStorageParams\n    ): StorageTransform.ToStorageResponse {\n        const { value, field, getStorageTransform, model } = params;\n        if (!value) {\n            return null;\n        }\n\n        const fields = (field.settings?.fields || []) as CmsModelField[];\n\n        if (field.list) {\n            return await pMap(value as GenericRecord[], value =>\n                processValue({\n                    sourceValue: value,\n                    getStorageTransform,\n                    model,\n                    operation: \"toStorage\",\n                    fields\n                })\n            );\n        }\n\n        return await processValue({\n            sourceValue: value,\n            getStorageTransform,\n            model,\n            operation: \"toStorage\",\n            fields\n        });\n    }\n\n    public async fromStorage(\n        params: StorageTransform.FromStorageParams\n    ): StorageTransform.FromStorageResponse {\n        const { field, value: input, getStorageTransform, model } = params;\n        if (!input) {\n            return null;\n        }\n\n        const fields = (field.settings?.fields || []) as CmsModelField[];\n\n        if (field.list) {\n            const values = input as GenericRecord[];\n\n            return await Promise.all(\n                values.map(async value => {\n                    return await processValue({\n                        sourceValue: value,\n                        getStorageTransform,\n                        model,\n                        operation: \"fromStorage\",\n                        fields\n                    });\n                })\n            );\n        }\n\n        return await processValue({\n            sourceValue: input,\n            getStorageTransform,\n            model,\n            operation: \"fromStorage\",\n            fields\n        });\n    }\n}\n\nexport const ObjectStorageTransform = StorageTransform.createImplementation({\n    implementation: StorageTransformImpl,\n    dependencies: []\n});\n"],"names":["processValue","params","fields","sourceValue","getStorageTransform","model","operation","pReduce","values","field","baseType","getBaseFieldType","storageTransform","Error","input","value","StorageTransformImpl","pMap","Promise","ObjectStorageTransform","StorageTransform"],"mappings":";;;;AAkBA,MAAMA,eAA6B,OAAMC;IACrC,MAAM,EAAEC,MAAM,EAAEC,WAAW,EAAEC,mBAAmB,EAAEC,KAAK,EAAEC,SAAS,EAAE,GAAGL;IACvE,OAAO,MAAMM,SACTL,QACA,OAAOM,QAAQC;QACX,MAAMC,WAAWC,iBAAiBF;QAClC,MAAMG,mBAAmBR,oBAAoBM;QAC7C,IAAI,CAACE,kBACD,MAAM,IAAIC,MAAM,CAAC,0CAA0C,EAAEH,SAAS,EAAE,CAAC;QAE7E,MAAMI,QAAQX,WAAW,CAACM,MAAM,OAAO,CAAC;QACxC,MAAMM,QAAQ,MAAMH,gBAAgB,CAACN,UAAU,CAAC;YAC5CD;YACAI;YACA,OAAOK;YACPV;QACJ;QACA,OAAO;YAAE,GAAGI,MAAM;YAAE,CAACC,MAAM,OAAO,CAAC,EAAEM;QAAM;IAC/C,GACA,CAAC;AAET;AAEA,MAAMC;IAGF,MAAa,UACTf,MAAwC,EACN;QAClC,MAAM,EAAEc,KAAK,EAAEN,KAAK,EAAEL,mBAAmB,EAAEC,KAAK,EAAE,GAAGJ;QACrD,IAAI,CAACc,OACD,OAAO;QAGX,MAAMb,SAAUO,MAAM,QAAQ,EAAE,UAAU,EAAE;QAE5C,IAAIA,MAAM,IAAI,EACV,OAAO,MAAMQ,MAAKF,OAA0BA,CAAAA,QACxCf,aAAa;gBACT,aAAae;gBACbX;gBACAC;gBACA,WAAW;gBACXH;YACJ;QAIR,OAAO,MAAMF,aAAa;YACtB,aAAae;YACbX;YACAC;YACA,WAAW;YACXH;QACJ;IACJ;IAEA,MAAa,YACTD,MAA0C,EACN;QACpC,MAAM,EAAEQ,KAAK,EAAE,OAAOK,KAAK,EAAEV,mBAAmB,EAAEC,KAAK,EAAE,GAAGJ;QAC5D,IAAI,CAACa,OACD,OAAO;QAGX,MAAMZ,SAAUO,MAAM,QAAQ,EAAE,UAAU,EAAE;QAE5C,IAAIA,MAAM,IAAI,EAAE;YACZ,MAAMD,SAASM;YAEf,OAAO,MAAMI,QAAQ,GAAG,CACpBV,OAAO,GAAG,CAAC,OAAMO,QACN,MAAMf,aAAa;oBACtB,aAAae;oBACbX;oBACAC;oBACA,WAAW;oBACXH;gBACJ;QAGZ;QAEA,OAAO,MAAMF,aAAa;YACtB,aAAac;YACbV;YACAC;YACA,WAAW;YACXH;QACJ;IACJ;;aAlEgB,SAAS,GAAG;;AAmEhC;AAEO,MAAMiB,yBAAyBC,iBAAiB,oBAAoB,CAAC;IACxE,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}

package/features/storage/fields/RichTextStorageTransform.d.ts

@@ -0,0 +1,13 @@
+import { StorageTransform } from "../abstractions/StorageTransform.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+declare class RichTextStorageTransformImpl implements StorageTransform.Interface {
+    private readonly compressionHandler;
+    readonly fieldType = "rich-text";
+    constructor(compressionHandler: CompressionHandler.Interface);
+    fromStorage({ field, value: storageValue }: StorageTransform.FromStorageParams): StorageTransform.FromStorageResponse;
+    toStorage({ value }: StorageTransform.ToStorageParams): StorageTransform.ToStorageResponse;
+}
+export declare const RichTextStorageTransform: typeof RichTextStorageTransformImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../abstractions/StorageTransform.js").IStorageTransform<any, any, any>>;
+};
+export {};