@webiny/api-headless-cms 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

package/features/storage/StorageTransformRegistry.d.ts

@@ -0,0 +1,14 @@
+import { StorageTransformRegistry as StorageTransformRegistryAbstraction } from "./abstractions/StorageTransformRegistry.js";
+import { StorageTransform } from "../../features/storage/abstractions/StorageTransform.js";
+import type { CmsModelField } from "../../types/index.js";
+declare class StorageTransformRegistryImpl implements StorageTransformRegistryAbstraction.Interface {
+    private readonly transforms;
+    private readonly cache;
+    constructor(transforms: StorageTransform.Interface[]);
+    get<T = any, R = any, F extends CmsModelField = CmsModelField>(fieldType: string): StorageTransform.Interface<T, R, F> | undefined;
+    getAll(): StorageTransform.Interface[];
+}
+export declare const StorageTransformRegistry: typeof StorageTransformRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/StorageTransformRegistry.js").IStorageTransformRegistry>;
+};
+export {};

package/features/storage/StorageTransformRegistry.js

@@ -0,0 +1,36 @@
+import { StorageTransformRegistry } from "./abstractions/StorageTransformRegistry.js";
+import { StorageTransform } from "./abstractions/StorageTransform.js";
+import { getBaseFieldType } from "../../utils/getBaseFieldType.js";
+class StorageTransformRegistryImpl {
+    constructor(transforms){
+        this.transforms = transforms;
+        this.cache = new Map();
+    }
+    get(fieldType) {
+        if (this.cache.has(fieldType)) return this.cache.get(fieldType);
+        let transform = this.transforms.find((item)=>item.fieldType === fieldType);
+        const baseType = getBaseFieldType({
+            type: fieldType
+        });
+        if (!transform && baseType !== fieldType) transform = this.transforms.find((item)=>item.fieldType === baseType);
+        this.cache.set(fieldType, transform);
+        return transform;
+    }
+    getAll() {
+        return this.transforms;
+    }
+}
+const StorageTransformRegistry_StorageTransformRegistry = StorageTransformRegistry.createImplementation({
+    implementation: StorageTransformRegistryImpl,
+    dependencies: [
+        [
+            StorageTransform,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { StorageTransformRegistry_StorageTransformRegistry as StorageTransformRegistry };
+
+//# sourceMappingURL=StorageTransformRegistry.js.map

package/features/storage/StorageTransformRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/StorageTransformRegistry.js","sources":["../../../src/features/storage/StorageTransformRegistry.ts"],"sourcesContent":["import { StorageTransformRegistry as StorageTransformRegistryAbstraction } from \"./abstractions/StorageTransformRegistry.js\";\nimport { StorageTransform } from \"~/features/storage/abstractions/StorageTransform.js\";\nimport type { CmsModelField } from \"~/types/index.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\n\nclass StorageTransformRegistryImpl implements StorageTransformRegistryAbstraction.Interface {\n    private readonly cache: Map<string, StorageTransform.Interface | undefined> = new Map();\n\n    public constructor(private readonly transforms: StorageTransform.Interface[]) {}\n\n    public get<T = any, R = any, F extends CmsModelField = CmsModelField>(\n        fieldType: string\n    ): StorageTransform.Interface<T, R, F> | undefined {\n        if (this.cache.has(fieldType)) {\n            return this.cache.get(fieldType) as StorageTransform.Interface<T, R, F>;\n        }\n\n        let transform = this.transforms.find(\n            (item): item is StorageTransform.Interface<T, R, F> => {\n                return item.fieldType === fieldType;\n            }\n        );\n\n        const baseType = getBaseFieldType({\n            type: fieldType\n        });\n        if (!transform && baseType !== fieldType) {\n            transform = this.transforms.find(\n                (item): item is StorageTransform.Interface<T, R, F> => {\n                    return item.fieldType === baseType;\n                }\n            );\n        }\n        this.cache.set(fieldType, transform);\n        return transform;\n    }\n\n    public getAll(): StorageTransform.Interface[] {\n        return this.transforms;\n    }\n}\n\nexport const StorageTransformRegistry = StorageTransformRegistryAbstraction.createImplementation({\n    implementation: StorageTransformRegistryImpl,\n    dependencies: [[StorageTransform, { multiple: true }]]\n});\n"],"names":["StorageTransformRegistryImpl","transforms","Map","fieldType","transform","item","baseType","getBaseFieldType","StorageTransformRegistry","StorageTransformRegistryAbstraction","StorageTransform"],"mappings":";;;AAKA,MAAMA;IAGF,YAAoCC,UAAwC,CAAE;aAA1CA,UAAU,GAAVA;aAFnB,KAAK,GAAwD,IAAIC;IAEH;IAExE,IACHC,SAAiB,EAC8B;QAC/C,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAACA,YACf,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAACA;QAG1B,IAAIC,YAAY,IAAI,CAAC,UAAU,CAAC,IAAI,CAChC,CAACC,OACUA,KAAK,SAAS,KAAKF;QAIlC,MAAMG,WAAWC,iBAAiB;YAC9B,MAAMJ;QACV;QACA,IAAI,CAACC,aAAaE,aAAaH,WAC3BC,YAAY,IAAI,CAAC,UAAU,CAAC,IAAI,CAC5B,CAACC,OACUA,KAAK,SAAS,KAAKC;QAItC,IAAI,CAAC,KAAK,CAAC,GAAG,CAACH,WAAWC;QAC1B,OAAOA;IACX;IAEO,SAAuC;QAC1C,OAAO,IAAI,CAAC,UAAU;IAC1B;AACJ;AAEO,MAAMI,oDAA2BC,yBAAAA,oBAAwD,CAAC;IAC7F,gBAAgBT;IAChB,cAAc;QAAC;YAACU;YAAkB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC1D"}

package/features/storage/abstractions/StorageTransform.d.ts

@@ -0,0 +1,26 @@
+import type { CmsModel, CmsModelField } from "../../../types/index.js";
+export interface IStorageTransformToStorageParams<T, R, F extends CmsModelField> {
+    model: CmsModel;
+    field: F;
+    value: T;
+    getStorageTransform(fieldType: string): IStorageTransform<T, R, F>;
+}
+export interface IStorageTransformFromStorageParams<T, R, F extends CmsModelField> {
+    model: CmsModel;
+    field: F;
+    value: T;
+    getStorageTransform(fieldType: string): IStorageTransform<T, R, F>;
+}
+export interface IStorageTransform<T, R, F extends CmsModelField> {
+    readonly fieldType: string;
+    toStorage(params: IStorageTransformToStorageParams<T, R, F>): Promise<R>;
+    fromStorage(params: IStorageTransformFromStorageParams<T, R, F>): Promise<T>;
+}
+export declare const StorageTransform: import("@webiny/di").Abstraction<IStorageTransform<any, any, any>>;
+export declare namespace StorageTransform {
+    type Interface<T = any, R = any, F extends CmsModelField = CmsModelField> = IStorageTransform<T, R, F>;
+    type ToStorageParams<T = any, R = any, F extends CmsModelField = CmsModelField> = IStorageTransformToStorageParams<T, R, F>;
+    type ToStorageResponse<T = any> = Promise<T>;
+    type FromStorageParams<T = any, R = any, F extends CmsModelField = CmsModelField> = IStorageTransformFromStorageParams<T, R, F>;
+    type FromStorageResponse<T = any> = Promise<T>;
+}

package/features/storage/abstractions/StorageTransform.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const StorageTransform = createAbstraction("Cms/Storage/Transform/Field");
+export { StorageTransform };
+
+//# sourceMappingURL=StorageTransform.js.map

package/features/storage/abstractions/StorageTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/abstractions/StorageTransform.js","sources":["../../../../src/features/storage/abstractions/StorageTransform.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel, CmsModelField } from \"~/types/index.js\";\n\nexport interface IStorageTransformToStorageParams<T, R, F extends CmsModelField> {\n    model: CmsModel;\n    field: F;\n    value: T;\n    getStorageTransform(fieldType: string): IStorageTransform<T, R, F>;\n}\n\nexport interface IStorageTransformFromStorageParams<T, R, F extends CmsModelField> {\n    model: CmsModel;\n    field: F;\n    value: T;\n    getStorageTransform(fieldType: string): IStorageTransform<T, R, F>;\n}\n\nexport interface IStorageTransform<T, R, F extends CmsModelField> {\n    readonly fieldType: string;\n    toStorage(params: IStorageTransformToStorageParams<T, R, F>): Promise<R>;\n    fromStorage(params: IStorageTransformFromStorageParams<T, R, F>): Promise<T>;\n}\n\nexport const StorageTransform = createAbstraction<IStorageTransform<any, any, any>>(\n    \"Cms/Storage/Transform/Field\"\n);\n\nexport namespace StorageTransform {\n    export type Interface<\n        T = any,\n        R = any,\n        F extends CmsModelField = CmsModelField\n    > = IStorageTransform<T, R, F>;\n    export type ToStorageParams<\n        T = any,\n        R = any,\n        F extends CmsModelField = CmsModelField\n    > = IStorageTransformToStorageParams<T, R, F>;\n    export type ToStorageResponse<T = any> = Promise<T>;\n    export type FromStorageParams<\n        T = any,\n        R = any,\n        F extends CmsModelField = CmsModelField\n    > = IStorageTransformFromStorageParams<T, R, F>;\n    export type FromStorageResponse<T = any> = Promise<T>;\n}\n"],"names":["StorageTransform","createAbstraction"],"mappings":";AAuBO,MAAMA,mBAAmBC,kBAC5B"}

package/features/storage/abstractions/StorageTransformRegistry.d.ts

@@ -0,0 +1,10 @@
+import { StorageTransform } from "./StorageTransform.js";
+import type { CmsModelField } from "../../../types/index.js";
+export interface IStorageTransformRegistry {
+    get<T = any, R = any, F extends CmsModelField = CmsModelField>(fieldType: string): StorageTransform.Interface<T, R, F> | undefined;
+    getAll(): StorageTransform.Interface[];
+}
+export declare const StorageTransformRegistry: import("@webiny/di").Abstraction<IStorageTransformRegistry>;
+export declare namespace StorageTransformRegistry {
+    type Interface = IStorageTransformRegistry;
+}

package/features/storage/abstractions/StorageTransformRegistry.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const StorageTransformRegistry = createAbstraction("Cms/Storage/Transform/Registry");
+export { StorageTransformRegistry };
+
+//# sourceMappingURL=StorageTransformRegistry.js.map

package/features/storage/abstractions/StorageTransformRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/abstractions/StorageTransformRegistry.js","sources":["../../../../src/features/storage/abstractions/StorageTransformRegistry.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { StorageTransform } from \"./StorageTransform.js\";\nimport type { CmsModelField } from \"~/types/index.js\";\n\nexport interface IStorageTransformRegistry {\n    get<T = any, R = any, F extends CmsModelField = CmsModelField>(\n        fieldType: string\n    ): StorageTransform.Interface<T, R, F> | undefined;\n    getAll(): StorageTransform.Interface[];\n}\n\nexport const StorageTransformRegistry = createAbstraction<IStorageTransformRegistry>(\n    \"Cms/Storage/Transform/Registry\"\n);\n\nexport namespace StorageTransformRegistry {\n    export type Interface = IStorageTransformRegistry;\n}\n"],"names":["StorageTransformRegistry","createAbstraction"],"mappings":";AAWO,MAAMA,2BAA2BC,kBACpC"}

package/features/storage/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const StorageFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/storage/feature.js

@@ -0,0 +1,29 @@
+import { createFeature } from "@webiny/feature/api";
+import { StorageTransformRegistry } from "./StorageTransformRegistry.js";
+import { DateStorageTransform } from "./fields/DateStorageTransform.js";
+import { DefaultStorageTransform } from "./fields/DefaultStorageTransform.js";
+import { JsonStorageTransform } from "./fields/JsonStorageTransform.js";
+import { DynamicZoneStorageTransform } from "./fields/DynamicZoneStorageTransform.js";
+import { LongTextStorageTransform } from "./fields/LongTextStorageTransform.js";
+import { ObjectStorageTransform } from "./fields/ObjectStorageTransform.js";
+import { RichTextStorageTransform } from "./fields/RichTextStorageTransform.js";
+import { CompressedTextStorageTransform } from "./fields/CompressedTextStorageTransform.js";
+import { EncryptedTextStorageTransform } from "./fields/EncryptedTextStorageTransform.js";
+const StorageFeature = createFeature({
+    name: "Cms/StorageFeature",
+    register: (container)=>{
+        container.register(DateStorageTransform).inSingletonScope();
+        container.register(DefaultStorageTransform).inSingletonScope();
+        container.register(DynamicZoneStorageTransform).inSingletonScope();
+        container.register(JsonStorageTransform).inSingletonScope();
+        container.register(LongTextStorageTransform).inSingletonScope();
+        container.register(ObjectStorageTransform).inSingletonScope();
+        container.register(RichTextStorageTransform).inSingletonScope();
+        container.register(CompressedTextStorageTransform).inSingletonScope();
+        container.register(EncryptedTextStorageTransform).inSingletonScope();
+        container.register(StorageTransformRegistry).inSingletonScope();
+    }
+});
+export { StorageFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/storage/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/storage/feature.js","sources":["../../../src/features/storage/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { StorageTransformRegistry } from \"./StorageTransformRegistry.js\";\nimport { DateStorageTransform } from \"./fields/DateStorageTransform.js\";\nimport { DefaultStorageTransform } from \"./fields/DefaultStorageTransform.js\";\nimport { JsonStorageTransform } from \"./fields/JsonStorageTransform.js\";\nimport { DynamicZoneStorageTransform } from \"./fields/DynamicZoneStorageTransform.js\";\nimport { LongTextStorageTransform } from \"./fields/LongTextStorageTransform.js\";\nimport { ObjectStorageTransform } from \"./fields/ObjectStorageTransform.js\";\nimport { RichTextStorageTransform } from \"./fields/RichTextStorageTransform.js\";\nimport { CompressedTextStorageTransform } from \"./fields/CompressedTextStorageTransform.js\";\nimport { EncryptedTextStorageTransform } from \"~/features/storage/fields/EncryptedTextStorageTransform.js\";\n\nexport const StorageFeature = createFeature({\n    name: \"Cms/StorageFeature\",\n    register: container => {\n        container.register(DateStorageTransform).inSingletonScope();\n        container.register(DefaultStorageTransform).inSingletonScope();\n        container.register(DynamicZoneStorageTransform).inSingletonScope();\n        container.register(JsonStorageTransform).inSingletonScope();\n        container.register(LongTextStorageTransform).inSingletonScope();\n        container.register(ObjectStorageTransform).inSingletonScope();\n        container.register(RichTextStorageTransform).inSingletonScope();\n        container.register(CompressedTextStorageTransform).inSingletonScope();\n        container.register(EncryptedTextStorageTransform).inSingletonScope();\n\n        // must be last, as it depends on all other transforms being registered first\n        container.register(StorageTransformRegistry).inSingletonScope();\n    }\n});\n"],"names":["StorageFeature","createFeature","container","DateStorageTransform","DefaultStorageTransform","DynamicZoneStorageTransform","JsonStorageTransform","LongTextStorageTransform","ObjectStorageTransform","RichTextStorageTransform","CompressedTextStorageTransform","EncryptedTextStorageTransform","StorageTransformRegistry"],"mappings":";;;;;;;;;;;AAYO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC,sBAAsB,gBAAgB;QACzDD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;QAC5DF,UAAU,QAAQ,CAACG,6BAA6B,gBAAgB;QAChEH,UAAU,QAAQ,CAACI,sBAAsB,gBAAgB;QACzDJ,UAAU,QAAQ,CAACK,0BAA0B,gBAAgB;QAC7DL,UAAU,QAAQ,CAACM,wBAAwB,gBAAgB;QAC3DN,UAAU,QAAQ,CAACO,0BAA0B,gBAAgB;QAC7DP,UAAU,QAAQ,CAACQ,gCAAgC,gBAAgB;QACnER,UAAU,QAAQ,CAACS,+BAA+B,gBAAgB;QAGlET,UAAU,QAAQ,CAACU,0BAA0B,gBAAgB;IACjE;AACJ"}

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

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

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