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

package/features/validation/validators/patterns/UrlPattern.d.ts

@@ -0,0 +1,12 @@
+import { CmsModelFieldPatternValidator } from "../../abstractions/CmsModelFieldPatternValidator.js";
+declare class UrlPatternImpl implements CmsModelFieldPatternValidator.Interface {
+    readonly pattern: {
+        name: string;
+        regex: string;
+        flags: string;
+    };
+}
+export declare const UrlPattern: typeof UrlPatternImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../../abstractions/CmsModelFieldPatternValidator.js").ICmsModelFieldPatternValidator>;
+};
+export {};

package/features/validation/validators/patterns/UrlPattern.js

@@ -0,0 +1,17 @@
+import { CmsModelFieldPatternValidator } from "../../abstractions/CmsModelFieldPatternValidator.js";
+class UrlPatternImpl {
+    constructor(){
+        this.pattern = {
+            name: "url",
+            regex: "^(ftp|http|https):\\/\\/(\\w+:{0,1}\\w*@)?(\\S+)(:[0-9]+)?(\\/|\\/([\\w#!:.?+=&%@!\\-\\/]))?$",
+            flags: "i"
+        };
+    }
+}
+const UrlPattern = CmsModelFieldPatternValidator.createImplementation({
+    implementation: UrlPatternImpl,
+    dependencies: []
+});
+export { UrlPattern };
+
+//# sourceMappingURL=UrlPattern.js.map

package/features/validation/validators/patterns/UrlPattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/validation/validators/patterns/UrlPattern.js","sources":["../../../../../src/features/validation/validators/patterns/UrlPattern.ts"],"sourcesContent":["import { CmsModelFieldPatternValidator } from \"../../abstractions/CmsModelFieldPatternValidator.js\";\n\nclass UrlPatternImpl implements CmsModelFieldPatternValidator.Interface {\n    public readonly pattern = {\n        name: \"url\",\n        regex: \"^(ftp|http|https):\\\\/\\\\/(\\\\w+:{0,1}\\\\w*@)?(\\\\S+)(:[0-9]+)?(\\\\/|\\\\/([\\\\w#!:.?+=&%@!\\\\-\\\\/]))?$\",\n        flags: \"i\"\n    };\n}\n\nexport const UrlPattern = CmsModelFieldPatternValidator.createImplementation({\n    implementation: UrlPatternImpl,\n    dependencies: []\n});\n"],"names":["UrlPatternImpl","UrlPattern","CmsModelFieldPatternValidator"],"mappings":";AAEA,MAAMA;;aACc,OAAO,GAAG;YACtB,MAAM;YACN,OAAO;YACP,OAAO;QACX;;AACJ;AAEO,MAAMC,aAAaC,8BAA8B,oBAAoB,CAAC;IACzE,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/webhooks/CmsWebhookFactory.d.ts

@@ -0,0 +1,11 @@
+import { WebhookFactory as WebhookFactoryAbstraction } from "@webiny/api-core/features/webhooks/index.js";
+import { ListModelsUseCase } from "../../features/contentModel/ListModels/abstractions.js";
+declare class CmsWebhookFactoryImpl implements WebhookFactoryAbstraction.Interface {
+    private listModels;
+    constructor(listModels: ListModelsUseCase.Interface);
+    execute(): Promise<WebhookFactoryAbstraction.Definition[]>;
+}
+export declare const CmsWebhookFactory: typeof CmsWebhookFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/webhooks/Webhook/abstractions/WebhookFactory").IWebhookFactory>;
+};
+export {};

package/features/webhooks/CmsWebhookFactory.js

@@ -0,0 +1,44 @@
+import { WebhookFactory } from "@webiny/api-core/features/webhooks/index.js";
+import { ListModelsUseCase } from "../contentModel/ListModels/abstractions.js";
+const ACTIONS = [
+    "created",
+    "updated",
+    "deleted",
+    "published",
+    "unpublished",
+    "trashed",
+    "restored"
+];
+class CmsWebhookFactoryImpl {
+    constructor(listModels){
+        this.listModels = listModels;
+    }
+    async execute() {
+        const result = await this.listModels.execute({
+            includePrivate: false,
+            includePlugins: true
+        });
+        if (result.isFail()) return [];
+        return result.value.reduce((events, model)=>{
+            if (model.tags?.includes("$hidden:true")) return events;
+            for (const action of ACTIONS)events.push({
+                app: "cms",
+                appLabel: "Headless CMS",
+                entity: model.modelId,
+                entityLabel: model.name,
+                eventName: `cms.entry.${model.modelId}.${action}`,
+                label: `Entry ${action.charAt(0).toUpperCase() + action.slice(1)}`
+            });
+            return events;
+        }, []);
+    }
+}
+const CmsWebhookFactory = WebhookFactory.createImplementation({
+    implementation: CmsWebhookFactoryImpl,
+    dependencies: [
+        ListModelsUseCase
+    ]
+});
+export { CmsWebhookFactory };
+
+//# sourceMappingURL=CmsWebhookFactory.js.map

package/features/webhooks/CmsWebhookFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/CmsWebhookFactory.js","sources":["../../../src/features/webhooks/CmsWebhookFactory.ts"],"sourcesContent":["import { WebhookFactory as WebhookFactoryAbstraction } from \"@webiny/api-core/features/webhooks/index.js\";\nimport { ListModelsUseCase } from \"~/features/contentModel/ListModels/abstractions.js\";\n\nconst ACTIONS = [\n    \"created\",\n    \"updated\",\n    \"deleted\",\n    \"published\",\n    \"unpublished\",\n    \"trashed\",\n    \"restored\"\n] as const;\n\nclass CmsWebhookFactoryImpl implements WebhookFactoryAbstraction.Interface {\n    constructor(private listModels: ListModelsUseCase.Interface) {}\n\n    public async execute(): Promise<WebhookFactoryAbstraction.Definition[]> {\n        const result = await this.listModels.execute({\n            includePrivate: false,\n            includePlugins: true\n        });\n        if (result.isFail()) {\n            return [];\n        }\n\n        return result.value.reduce<WebhookFactoryAbstraction.Definition[]>((events, model) => {\n            if (model.tags?.includes(\"$hidden:true\")) {\n                return events;\n            }\n\n            for (const action of ACTIONS) {\n                events.push({\n                    app: \"cms\",\n                    appLabel: \"Headless CMS\",\n                    entity: model.modelId,\n                    entityLabel: model.name,\n                    eventName: `cms.entry.${model.modelId}.${action}`,\n                    label: `Entry ${action.charAt(0).toUpperCase() + action.slice(1)}`\n                });\n            }\n            return events;\n        }, []);\n    }\n}\n\nexport const CmsWebhookFactory = WebhookFactoryAbstraction.createImplementation({\n    implementation: CmsWebhookFactoryImpl,\n    dependencies: [ListModelsUseCase]\n});\n"],"names":["ACTIONS","CmsWebhookFactoryImpl","listModels","result","events","model","action","CmsWebhookFactory","WebhookFactoryAbstraction","ListModelsUseCase"],"mappings":";;AAGA,MAAMA,UAAU;IACZ;IACA;IACA;IACA;IACA;IACA;IACA;CACH;AAED,MAAMC;IACF,YAAoBC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAE9D,MAAa,UAA2D;QACpE,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YACzC,gBAAgB;YAChB,gBAAgB;QACpB;QACA,IAAIA,OAAO,MAAM,IACb,OAAO,EAAE;QAGb,OAAOA,OAAO,KAAK,CAAC,MAAM,CAAyC,CAACC,QAAQC;YACxE,IAAIA,MAAM,IAAI,EAAE,SAAS,iBACrB,OAAOD;YAGX,KAAK,MAAME,UAAUN,QACjBI,OAAO,IAAI,CAAC;gBACR,KAAK;gBACL,UAAU;gBACV,QAAQC,MAAM,OAAO;gBACrB,aAAaA,MAAM,IAAI;gBACvB,WAAW,CAAC,UAAU,EAAEA,MAAM,OAAO,CAAC,CAAC,EAAEC,QAAQ;gBACjD,OAAO,CAAC,MAAM,EAAEA,OAAO,MAAM,CAAC,GAAG,WAAW,KAAKA,OAAO,KAAK,CAAC,IAAI;YACtE;YAEJ,OAAOF;QACX,GAAG,EAAE;IACT;AACJ;AAEO,MAAMG,oBAAoBC,eAAAA,oBAA8C,CAAC;IAC5E,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/features/webhooks/feature.d.ts

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

package/features/webhooks/feature.js

@@ -0,0 +1,25 @@
+import { createFeature } from "@webiny/feature/api";
+import { CmsWebhookFactory } from "./CmsWebhookFactory.js";
+import { OnEntryCreatedHandler } from "./handlers/OnEntryCreatedHandler.js";
+import { OnEntryUpdatedHandler } from "./handlers/OnEntryUpdatedHandler.js";
+import { OnEntryDeletedHandler } from "./handlers/OnEntryDeletedHandler.js";
+import { OnEntryPublishedHandler } from "./handlers/OnEntryPublishedHandler.js";
+import { OnEntryUnpublishedHandler } from "./handlers/OnEntryUnpublishedHandler.js";
+import { OnEntryTrashedHandler } from "./handlers/OnEntryTrashedHandler.js";
+import { OnEntryRestoredHandler } from "./handlers/OnEntryRestoredHandler.js";
+const CmsWebhooksFeature = createFeature({
+    name: "CmsWebhooks",
+    register (container) {
+        container.register(CmsWebhookFactory).inSingletonScope();
+        container.register(OnEntryCreatedHandler);
+        container.register(OnEntryUpdatedHandler);
+        container.register(OnEntryDeletedHandler);
+        container.register(OnEntryPublishedHandler);
+        container.register(OnEntryUnpublishedHandler);
+        container.register(OnEntryTrashedHandler);
+        container.register(OnEntryRestoredHandler);
+    }
+});
+export { CmsWebhooksFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/webhooks/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/feature.js","sources":["../../../src/features/webhooks/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CmsWebhookFactory } from \"./CmsWebhookFactory.js\";\nimport { OnEntryCreatedHandler } from \"./handlers/OnEntryCreatedHandler.js\";\nimport { OnEntryUpdatedHandler } from \"./handlers/OnEntryUpdatedHandler.js\";\nimport { OnEntryDeletedHandler } from \"./handlers/OnEntryDeletedHandler.js\";\nimport { OnEntryPublishedHandler } from \"./handlers/OnEntryPublishedHandler.js\";\nimport { OnEntryUnpublishedHandler } from \"./handlers/OnEntryUnpublishedHandler.js\";\nimport { OnEntryTrashedHandler } from \"./handlers/OnEntryTrashedHandler.js\";\nimport { OnEntryRestoredHandler } from \"./handlers/OnEntryRestoredHandler.js\";\n\nexport const CmsWebhooksFeature = createFeature({\n    name: \"CmsWebhooks\",\n    register(container) {\n        container.register(CmsWebhookFactory).inSingletonScope();\n        container.register(OnEntryCreatedHandler);\n        container.register(OnEntryUpdatedHandler);\n        container.register(OnEntryDeletedHandler);\n        container.register(OnEntryPublishedHandler);\n        container.register(OnEntryUnpublishedHandler);\n        container.register(OnEntryTrashedHandler);\n        container.register(OnEntryRestoredHandler);\n    }\n});\n"],"names":["CmsWebhooksFeature","createFeature","container","CmsWebhookFactory","OnEntryCreatedHandler","OnEntryUpdatedHandler","OnEntryDeletedHandler","OnEntryPublishedHandler","OnEntryUnpublishedHandler","OnEntryTrashedHandler","OnEntryRestoredHandler"],"mappings":";;;;;;;;;AAUO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,mBAAmB,gBAAgB;QACtDD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;IACvB;AACJ"}

package/features/webhooks/handlers/OnEntryCreatedHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterCreateEventHandler } from "../../../features/contentEntry/CreateEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+declare class OnEntryCreatedHandlerImpl implements EntryAfterCreateEventHandler.Interface {
+    private dispatcher;
+    constructor(dispatcher: WebhookDispatcher.Interface);
+    handle(event: EntryAfterCreateEventHandler.Event): Promise<void>;
+}
+export declare const OnEntryCreatedHandler: typeof OnEntryCreatedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("~/features/contentEntry/CreateEntry/events.js").EntryAfterCreateEvent>>;
+};
+export {};

package/features/webhooks/handlers/OnEntryCreatedHandler.js

@@ -0,0 +1,22 @@
+import { EntryAfterCreateEventHandler } from "../../contentEntry/CreateEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+class OnEntryCreatedHandlerImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.created`, {
+            entry
+        });
+    }
+}
+const OnEntryCreatedHandler = EntryAfterCreateEventHandler.createImplementation({
+    implementation: OnEntryCreatedHandlerImpl,
+    dependencies: [
+        WebhookDispatcher
+    ]
+});
+export { OnEntryCreatedHandler };
+
+//# sourceMappingURL=OnEntryCreatedHandler.js.map

package/features/webhooks/handlers/OnEntryCreatedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/handlers/OnEntryCreatedHandler.js","sources":["../../../../src/features/webhooks/handlers/OnEntryCreatedHandler.ts"],"sourcesContent":["import { EntryAfterCreateEventHandler } from \"~/features/contentEntry/CreateEntry/events.js\";\nimport { WebhookDispatcher } from \"@webiny/api-core/features/webhooks/index.js\";\n\nclass OnEntryCreatedHandlerImpl implements EntryAfterCreateEventHandler.Interface {\n    constructor(private dispatcher: WebhookDispatcher.Interface) {}\n\n    async handle(event: EntryAfterCreateEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.created`, { entry });\n    }\n}\n\nexport const OnEntryCreatedHandler = EntryAfterCreateEventHandler.createImplementation({\n    implementation: OnEntryCreatedHandlerImpl,\n    dependencies: [WebhookDispatcher]\n});\n"],"names":["OnEntryCreatedHandlerImpl","dispatcher","event","entry","model","OnEntryCreatedHandler","EntryAfterCreateEventHandler","WebhookDispatcher"],"mappings":";;AAGA,MAAMA;IACF,YAAoBC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAE9D,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QACtC,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAEE,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE;YAAED;QAAM;IACjF;AACJ;AAEO,MAAME,wBAAwBC,6BAA6B,oBAAoB,CAAC;IACnF,gBAAgBN;IAChB,cAAc;QAACO;KAAkB;AACrC"}

package/features/webhooks/handlers/OnEntryDeletedHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterDeleteEventHandler } from "../../../features/contentEntry/DeleteEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+declare class OnEntryDeletedHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
+    private readonly dispatcher;
+    constructor(dispatcher: WebhookDispatcher.Interface);
+    handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const OnEntryDeletedHandler: typeof OnEntryDeletedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("~/features/contentEntry/DeleteEntry/events.js").EntryAfterDeleteEvent>>;
+};
+export {};

package/features/webhooks/handlers/OnEntryDeletedHandler.js

@@ -0,0 +1,23 @@
+import { EntryAfterDeleteEventHandler } from "../../contentEntry/DeleteEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+class OnEntryDeletedHandlerImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    async handle(event) {
+        const { entry, model, permanent } = event.payload;
+        if (!permanent) return;
+        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.deleted`, {
+            entry
+        });
+    }
+}
+const OnEntryDeletedHandler = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: OnEntryDeletedHandlerImpl,
+    dependencies: [
+        WebhookDispatcher
+    ]
+});
+export { OnEntryDeletedHandler };
+
+//# sourceMappingURL=OnEntryDeletedHandler.js.map

package/features/webhooks/handlers/OnEntryDeletedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/handlers/OnEntryDeletedHandler.js","sources":["../../../../src/features/webhooks/handlers/OnEntryDeletedHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"~/features/contentEntry/DeleteEntry/events.js\";\nimport { WebhookDispatcher } from \"@webiny/api-core/features/webhooks/index.js\";\n\nclass OnEntryDeletedHandlerImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(private readonly dispatcher: WebhookDispatcher.Interface) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model, permanent } = event.payload;\n        if (!permanent) {\n            return;\n        }\n        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.deleted`, { entry });\n    }\n}\n\nexport const OnEntryDeletedHandler = EntryAfterDeleteEventHandler.createImplementation({\n    implementation: OnEntryDeletedHandlerImpl,\n    dependencies: [WebhookDispatcher]\n});\n"],"names":["OnEntryDeletedHandlerImpl","dispatcher","event","entry","model","permanent","OnEntryDeletedHandler","EntryAfterDeleteEventHandler","WebhookDispatcher"],"mappings":";;AAGA,MAAMA;IACF,YAA6BC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAEvE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,SAAS,EAAE,GAAGH,MAAM,OAAO;QACjD,IAAI,CAACG,WACD;QAEJ,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAED,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE;YAAED;QAAM;IACjF;AACJ;AAEO,MAAMG,wBAAwBC,6BAA6B,oBAAoB,CAAC;IACnF,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/features/webhooks/handlers/OnEntryPublishedHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterPublishEventHandler } from "../../../features/contentEntry/PublishEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+declare class OnEntryPublishedHandlerImpl implements EntryAfterPublishEventHandler.Interface {
+    private dispatcher;
+    constructor(dispatcher: WebhookDispatcher.Interface);
+    handle(event: EntryAfterPublishEventHandler.Event): Promise<void>;
+}
+export declare const OnEntryPublishedHandler: typeof OnEntryPublishedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("~/features/contentEntry/PublishEntry/events.js").EntryAfterPublishEvent>>;
+};
+export {};

package/features/webhooks/handlers/OnEntryPublishedHandler.js

@@ -0,0 +1,22 @@
+import { EntryAfterPublishEventHandler } from "../../contentEntry/PublishEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+class OnEntryPublishedHandlerImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.published`, {
+            entry
+        });
+    }
+}
+const OnEntryPublishedHandler = EntryAfterPublishEventHandler.createImplementation({
+    implementation: OnEntryPublishedHandlerImpl,
+    dependencies: [
+        WebhookDispatcher
+    ]
+});
+export { OnEntryPublishedHandler };
+
+//# sourceMappingURL=OnEntryPublishedHandler.js.map

package/features/webhooks/handlers/OnEntryPublishedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/handlers/OnEntryPublishedHandler.js","sources":["../../../../src/features/webhooks/handlers/OnEntryPublishedHandler.ts"],"sourcesContent":["import { EntryAfterPublishEventHandler } from \"~/features/contentEntry/PublishEntry/events.js\";\nimport { WebhookDispatcher } from \"@webiny/api-core/features/webhooks/index.js\";\n\nclass OnEntryPublishedHandlerImpl implements EntryAfterPublishEventHandler.Interface {\n    constructor(private dispatcher: WebhookDispatcher.Interface) {}\n\n    async handle(event: EntryAfterPublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.published`, { entry });\n    }\n}\n\nexport const OnEntryPublishedHandler = EntryAfterPublishEventHandler.createImplementation({\n    implementation: OnEntryPublishedHandlerImpl,\n    dependencies: [WebhookDispatcher]\n});\n"],"names":["OnEntryPublishedHandlerImpl","dispatcher","event","entry","model","OnEntryPublishedHandler","EntryAfterPublishEventHandler","WebhookDispatcher"],"mappings":";;AAGA,MAAMA;IACF,YAAoBC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAE9D,MAAM,OAAOC,KAA0C,EAAiB;QACpE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QACtC,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAEE,MAAM,OAAO,CAAC,UAAU,CAAC,EAAE;YAAED;QAAM;IACnF;AACJ;AAEO,MAAME,0BAA0BC,8BAA8B,oBAAoB,CAAC;IACtF,gBAAgBN;IAChB,cAAc;QAACO;KAAkB;AACrC"}

package/features/webhooks/handlers/OnEntryRestoredHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterRestoreFromBinEventHandler } from "../../../features/contentEntry/RestoreEntryFromBin/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+declare class OnEntryRestoredHandlerImpl implements EntryAfterRestoreFromBinEventHandler.Interface {
+    private readonly dispatcher;
+    constructor(dispatcher: WebhookDispatcher.Interface);
+    handle(event: EntryAfterRestoreFromBinEventHandler.Event): Promise<void>;
+}
+export declare const OnEntryRestoredHandler: typeof OnEntryRestoredHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("~/features/contentEntry/RestoreEntryFromBin/events.js").EntryAfterRestoreFromBinEvent>>;
+};
+export {};

package/features/webhooks/handlers/OnEntryRestoredHandler.js

@@ -0,0 +1,22 @@
+import { EntryAfterRestoreFromBinEventHandler } from "../../contentEntry/RestoreEntryFromBin/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+class OnEntryRestoredHandlerImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.restored`, {
+            entry
+        });
+    }
+}
+const OnEntryRestoredHandler = EntryAfterRestoreFromBinEventHandler.createImplementation({
+    implementation: OnEntryRestoredHandlerImpl,
+    dependencies: [
+        WebhookDispatcher
+    ]
+});
+export { OnEntryRestoredHandler };
+
+//# sourceMappingURL=OnEntryRestoredHandler.js.map

package/features/webhooks/handlers/OnEntryRestoredHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/handlers/OnEntryRestoredHandler.js","sources":["../../../../src/features/webhooks/handlers/OnEntryRestoredHandler.ts"],"sourcesContent":["import { EntryAfterRestoreFromBinEventHandler } from \"~/features/contentEntry/RestoreEntryFromBin/events.js\";\nimport { WebhookDispatcher } from \"@webiny/api-core/features/webhooks/index.js\";\n\nclass OnEntryRestoredHandlerImpl implements EntryAfterRestoreFromBinEventHandler.Interface {\n    constructor(private readonly dispatcher: WebhookDispatcher.Interface) {}\n\n    async handle(event: EntryAfterRestoreFromBinEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.restored`, { entry });\n    }\n}\n\nexport const OnEntryRestoredHandler = EntryAfterRestoreFromBinEventHandler.createImplementation({\n    implementation: OnEntryRestoredHandlerImpl,\n    dependencies: [WebhookDispatcher]\n});\n"],"names":["OnEntryRestoredHandlerImpl","dispatcher","event","entry","model","OnEntryRestoredHandler","EntryAfterRestoreFromBinEventHandler","WebhookDispatcher"],"mappings":";;AAGA,MAAMA;IACF,YAA6BC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAEvE,MAAM,OAAOC,KAAiD,EAAiB;QAC3E,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QACtC,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAEE,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE;YAAED;QAAM;IAClF;AACJ;AAEO,MAAME,yBAAyBC,qCAAqC,oBAAoB,CAAC;IAC5F,gBAAgBN;IAChB,cAAc;QAACO;KAAkB;AACrC"}

package/features/webhooks/handlers/OnEntryTrashedHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterDeleteEventHandler } from "../../../features/contentEntry/DeleteEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+declare class OnEntryTrashedHandlerImpl implements EntryAfterDeleteEventHandler.Interface {
+    private readonly dispatcher;
+    constructor(dispatcher: WebhookDispatcher.Interface);
+    handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const OnEntryTrashedHandler: typeof OnEntryTrashedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("~/features/contentEntry/DeleteEntry/events.js").EntryAfterDeleteEvent>>;
+};
+export {};

package/features/webhooks/handlers/OnEntryTrashedHandler.js

@@ -0,0 +1,23 @@
+import { EntryAfterDeleteEventHandler } from "../../contentEntry/DeleteEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+class OnEntryTrashedHandlerImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    async handle(event) {
+        const { entry, model, permanent } = event.payload;
+        if (permanent) return;
+        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.trashed`, {
+            entry
+        });
+    }
+}
+const OnEntryTrashedHandler = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: OnEntryTrashedHandlerImpl,
+    dependencies: [
+        WebhookDispatcher
+    ]
+});
+export { OnEntryTrashedHandler };
+
+//# sourceMappingURL=OnEntryTrashedHandler.js.map

package/features/webhooks/handlers/OnEntryTrashedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/handlers/OnEntryTrashedHandler.js","sources":["../../../../src/features/webhooks/handlers/OnEntryTrashedHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"~/features/contentEntry/DeleteEntry/events.js\";\nimport { WebhookDispatcher } from \"@webiny/api-core/features/webhooks/index.js\";\n\nclass OnEntryTrashedHandlerImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(private readonly dispatcher: WebhookDispatcher.Interface) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model, permanent } = event.payload;\n        if (permanent) {\n            return;\n        }\n        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.trashed`, { entry });\n    }\n}\n\nexport const OnEntryTrashedHandler = EntryAfterDeleteEventHandler.createImplementation({\n    implementation: OnEntryTrashedHandlerImpl,\n    dependencies: [WebhookDispatcher]\n});\n"],"names":["OnEntryTrashedHandlerImpl","dispatcher","event","entry","model","permanent","OnEntryTrashedHandler","EntryAfterDeleteEventHandler","WebhookDispatcher"],"mappings":";;AAGA,MAAMA;IACF,YAA6BC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAEvE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,SAAS,EAAE,GAAGH,MAAM,OAAO;QACjD,IAAIG,WACA;QAEJ,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAED,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE;YAAED;QAAM;IACjF;AACJ;AAEO,MAAMG,wBAAwBC,6BAA6B,oBAAoB,CAAC;IACnF,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/features/webhooks/handlers/OnEntryUnpublishedHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterUnpublishEventHandler } from "../../../features/contentEntry/UnpublishEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+declare class OnEntryUnpublishedHandlerImpl implements EntryAfterUnpublishEventHandler.Interface {
+    private dispatcher;
+    constructor(dispatcher: WebhookDispatcher.Interface);
+    handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void>;
+}
+export declare const OnEntryUnpublishedHandler: typeof OnEntryUnpublishedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("~/features/contentEntry/UnpublishEntry/events.js").EntryAfterUnpublishEvent>>;
+};
+export {};

package/features/webhooks/handlers/OnEntryUnpublishedHandler.js

@@ -0,0 +1,22 @@
+import { EntryAfterUnpublishEventHandler } from "../../contentEntry/UnpublishEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+class OnEntryUnpublishedHandlerImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    async handle(event) {
+        const { entry, model } = event.payload;
+        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.unpublished`, {
+            entry
+        });
+    }
+}
+const OnEntryUnpublishedHandler = EntryAfterUnpublishEventHandler.createImplementation({
+    implementation: OnEntryUnpublishedHandlerImpl,
+    dependencies: [
+        WebhookDispatcher
+    ]
+});
+export { OnEntryUnpublishedHandler };
+
+//# sourceMappingURL=OnEntryUnpublishedHandler.js.map

package/features/webhooks/handlers/OnEntryUnpublishedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/handlers/OnEntryUnpublishedHandler.js","sources":["../../../../src/features/webhooks/handlers/OnEntryUnpublishedHandler.ts"],"sourcesContent":["import { EntryAfterUnpublishEventHandler } from \"~/features/contentEntry/UnpublishEntry/events.js\";\nimport { WebhookDispatcher } from \"@webiny/api-core/features/webhooks/index.js\";\n\nclass OnEntryUnpublishedHandlerImpl implements EntryAfterUnpublishEventHandler.Interface {\n    constructor(private dispatcher: WebhookDispatcher.Interface) {}\n\n    async handle(event: EntryAfterUnpublishEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.unpublished`, { entry });\n    }\n}\n\nexport const OnEntryUnpublishedHandler = EntryAfterUnpublishEventHandler.createImplementation({\n    implementation: OnEntryUnpublishedHandlerImpl,\n    dependencies: [WebhookDispatcher]\n});\n"],"names":["OnEntryUnpublishedHandlerImpl","dispatcher","event","entry","model","OnEntryUnpublishedHandler","EntryAfterUnpublishEventHandler","WebhookDispatcher"],"mappings":";;AAGA,MAAMA;IACF,YAAoBC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAE9D,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QACtC,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAEE,MAAM,OAAO,CAAC,YAAY,CAAC,EAAE;YAAED;QAAM;IACrF;AACJ;AAEO,MAAME,4BAA4BC,gCAAgC,oBAAoB,CAAC;IAC1F,gBAAgBN;IAChB,cAAc;QAACO;KAAkB;AACrC"}

package/features/webhooks/handlers/OnEntryUpdatedHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterUpdateEventHandler } from "../../../features/contentEntry/UpdateEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+declare class OnEntryUpdatedHandlerImpl implements EntryAfterUpdateEventHandler.Interface {
+    private dispatcher;
+    constructor(dispatcher: WebhookDispatcher.Interface);
+    handle(event: EntryAfterUpdateEventHandler.Event): Promise<void>;
+}
+export declare const OnEntryUpdatedHandler: typeof OnEntryUpdatedHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("~/features/contentEntry/UpdateEntry/events.js").EntryAfterUpdateEvent>>;
+};
+export {};

package/features/webhooks/handlers/OnEntryUpdatedHandler.js

@@ -0,0 +1,23 @@
+import { EntryAfterUpdateEventHandler } from "../../contentEntry/UpdateEntry/events.js";
+import { WebhookDispatcher } from "@webiny/api-core/features/webhooks/index.js";
+class OnEntryUpdatedHandlerImpl {
+    constructor(dispatcher){
+        this.dispatcher = dispatcher;
+    }
+    async handle(event) {
+        const { entry, model, original } = event.payload;
+        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.updated`, {
+            entry,
+            original
+        });
+    }
+}
+const OnEntryUpdatedHandler = EntryAfterUpdateEventHandler.createImplementation({
+    implementation: OnEntryUpdatedHandlerImpl,
+    dependencies: [
+        WebhookDispatcher
+    ]
+});
+export { OnEntryUpdatedHandler };
+
+//# sourceMappingURL=OnEntryUpdatedHandler.js.map

package/features/webhooks/handlers/OnEntryUpdatedHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/webhooks/handlers/OnEntryUpdatedHandler.js","sources":["../../../../src/features/webhooks/handlers/OnEntryUpdatedHandler.ts"],"sourcesContent":["import { EntryAfterUpdateEventHandler } from \"~/features/contentEntry/UpdateEntry/events.js\";\nimport { WebhookDispatcher } from \"@webiny/api-core/features/webhooks/index.js\";\n\nclass OnEntryUpdatedHandlerImpl implements EntryAfterUpdateEventHandler.Interface {\n    constructor(private dispatcher: WebhookDispatcher.Interface) {}\n\n    async handle(event: EntryAfterUpdateEventHandler.Event): Promise<void> {\n        const { entry, model, original } = event.payload;\n        await this.dispatcher.dispatch(`cms.entry.${model.modelId}.updated`, { entry, original });\n    }\n}\n\nexport const OnEntryUpdatedHandler = EntryAfterUpdateEventHandler.createImplementation({\n    implementation: OnEntryUpdatedHandlerImpl,\n    dependencies: [WebhookDispatcher]\n});\n"],"names":["OnEntryUpdatedHandlerImpl","dispatcher","event","entry","model","original","OnEntryUpdatedHandler","EntryAfterUpdateEventHandler","WebhookDispatcher"],"mappings":";;AAGA,MAAMA;IACF,YAAoBC,UAAuC,CAAE;aAAzCA,UAAU,GAAVA;IAA0C;IAE9D,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGH,MAAM,OAAO;QAChD,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,UAAU,EAAEE,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE;YAAED;YAAOE;QAAS;IAC3F;AACJ;AAEO,MAAMC,wBAAwBC,6BAA6B,oBAAoB,CAAC;IACnF,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/features/whereMapper/DEVELOPER.md

@@ -0,0 +1,29 @@
+# Cms Where Mapper
+
+The mapper is used to convert a private model GraphQL `where` to one that can be used within the CMS methods.
+
+For example, private model can have field `title`. The `where` parameter can contain a filter for that field like this:
+
+```graphql
+{
+    where: {
+        title_contains: "My Title"
+    }
+}
+```
+
+When passing the `where` int CMS list/get or similar methods, user must pass the `where` variable through the
+CmsWhereMapper.map method so it is converted to something like:
+
+```graphql
+{
+    where: {
+        values: {
+            title_contains: "My Title"
+        }
+    }
+}
+```
+
+The reason behind it is that we store all user defined values in a nested `values` object in the database, so all
+filters must be applied to that object.

package/features/whereMapper/WhereMapper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Used to map a model with custom schema with fields in a root to values object.
+ * eg. File Manager File model has "title" and "tags" fields in the root, but they should be
+ * mapped to "values.title" and "values.tags" when creating the entry.
+ */
+import { GenericRecord } from "@webiny/api/types.js";
+import { CmsEntryListWhere } from "../../types/types.js";
+import { CmsWhereMapper, ICmsWhereMapperParams } from "./abstractions.js";
+declare class WhereMapperImpl implements CmsWhereMapper.Interface {
+    map<T extends GenericRecord>(params: ICmsWhereMapperParams<T>): CmsEntryListWhere | undefined;
+    private mapWhere;
+}
+export declare const WhereMapper: typeof WhereMapperImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICmsWhereMapper>;
+};
+export {};

package/features/whereMapper/WhereMapper.js

@@ -0,0 +1,52 @@
+import { CmsWhereMapper } from "./abstractions.js";
+const isPlainObject = (value)=>{
+    if (!value || "object" != typeof value) return false;
+    if (Array.isArray(value)) return false;
+    return true;
+};
+const isLogicalKey = (key)=>"AND" === key || "OR" === key;
+class WhereMapperImpl {
+    map(params) {
+        const { fields: modelFields, input } = params;
+        if (!input) return;
+        const fields = modelFields.map((field)=>field.fieldId);
+        const isField = (key)=>{
+            const field = key.split("_")[0];
+            return fields.includes(field);
+        };
+        return this.mapWhere({
+            input,
+            isField
+        });
+    }
+    mapWhere(params) {
+        const { input, isField } = params;
+        const out = {};
+        const keys = Object.keys(input);
+        if (0 === keys.length) return out;
+        for (const key of keys){
+            const value = input[key];
+            if (isLogicalKey(key)) {
+                if (Array.isArray(value)) out[key] = value.filter(isPlainObject).map((child)=>this.mapWhere({
+                        input: child,
+                        isField
+                    }));
+                continue;
+            }
+            if (isField(key)) {
+                if (!out.values) out.values = {};
+                out.values[key] = value;
+                continue;
+            }
+            out[key] = value;
+        }
+        return out;
+    }
+}
+const WhereMapper = CmsWhereMapper.createImplementation({
+    implementation: WhereMapperImpl,
+    dependencies: []
+});
+export { WhereMapper };
+
+//# sourceMappingURL=WhereMapper.js.map

package/features/whereMapper/WhereMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/whereMapper/WhereMapper.js","sources":["../../../src/features/whereMapper/WhereMapper.ts"],"sourcesContent":["/**\n * Used to map a model with custom schema with fields in a root to values object.\n * eg. File Manager File model has \"title\" and \"tags\" fields in the root, but they should be\n * mapped to \"values.title\" and \"values.tags\" when creating the entry.\n */\nimport { GenericRecord } from \"@webiny/api/types.js\";\nimport { CmsEntryListWhere } from \"~/types/types.js\";\nimport { CmsWhereMapper, ICmsWhereMapperParams } from \"./abstractions.js\";\n\nconst isPlainObject = (value: unknown): value is Record<string, unknown> => {\n    if (!value || typeof value !== \"object\") {\n        return false;\n    } else if (Array.isArray(value)) {\n        return false;\n    }\n    return true;\n};\n\nconst isLogicalKey = (key: string): key is \"AND\" | \"OR\" => {\n    return key === \"AND\" || key === \"OR\";\n};\n\ninterface IMapNodeWhereParams {\n    input: GenericRecord;\n    isField: (key: string) => boolean;\n}\n\nclass WhereMapperImpl implements CmsWhereMapper.Interface {\n    map<T extends GenericRecord>(params: ICmsWhereMapperParams<T>): CmsEntryListWhere | undefined {\n        const { fields: modelFields, input } = params;\n        if (!input) {\n            return undefined;\n        }\n\n        const fields = modelFields.map(field => {\n            return field.fieldId;\n        });\n\n        const isField = (key: string): boolean => {\n            const field = key.split(\"_\")[0];\n            return fields.includes(field);\n        };\n\n        return this.mapWhere({\n            input,\n            isField\n        });\n    }\n\n    private mapWhere(params: IMapNodeWhereParams) {\n        const { input, isField } = params;\n        const out: CmsEntryListWhere = {};\n\n        const keys = Object.keys(input) as (keyof typeof out)[];\n        if (keys.length === 0) {\n            return out;\n        }\n\n        for (const key of keys) {\n            const value = input[key];\n\n            if (isLogicalKey(key)) {\n                if (Array.isArray(value)) {\n                    out[key] = value.filter(isPlainObject).map(child => {\n                        return this.mapWhere({\n                            input: child,\n                            isField\n                        });\n                    });\n                }\n                continue;\n            } else if (isField(key)) {\n                if (!out.values) {\n                    out.values = {};\n                }\n                out.values[key] = value;\n                continue;\n            }\n\n            out[key] = value;\n        }\n\n        return out;\n    }\n}\n\nexport const WhereMapper = CmsWhereMapper.createImplementation({\n    implementation: WhereMapperImpl,\n    dependencies: []\n});\n"],"names":["isPlainObject","value","Array","isLogicalKey","key","WhereMapperImpl","params","modelFields","input","fields","field","isField","out","keys","Object","child","WhereMapper","CmsWhereMapper"],"mappings":";AASA,MAAMA,gBAAgB,CAACC;IACnB,IAAI,CAACA,SAAS,AAAiB,YAAjB,OAAOA,OACjB,OAAO;IACJ,IAAIC,MAAM,OAAO,CAACD,QACrB,OAAO;IAEX,OAAO;AACX;AAEA,MAAME,eAAe,CAACC,MACXA,AAAQ,UAARA,OAAiBA,AAAQ,SAARA;AAQ5B,MAAMC;IACF,IAA6BC,MAAgC,EAAiC;QAC1F,MAAM,EAAE,QAAQC,WAAW,EAAEC,KAAK,EAAE,GAAGF;QACvC,IAAI,CAACE,OACD;QAGJ,MAAMC,SAASF,YAAY,GAAG,CAACG,CAAAA,QACpBA,MAAM,OAAO;QAGxB,MAAMC,UAAU,CAACP;YACb,MAAMM,QAAQN,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE;YAC/B,OAAOK,OAAO,QAAQ,CAACC;QAC3B;QAEA,OAAO,IAAI,CAAC,QAAQ,CAAC;YACjBF;YACAG;QACJ;IACJ;IAEQ,SAASL,MAA2B,EAAE;QAC1C,MAAM,EAAEE,KAAK,EAAEG,OAAO,EAAE,GAAGL;QAC3B,MAAMM,MAAyB,CAAC;QAEhC,MAAMC,OAAOC,OAAO,IAAI,CAACN;QACzB,IAAIK,AAAgB,MAAhBA,KAAK,MAAM,EACX,OAAOD;QAGX,KAAK,MAAMR,OAAOS,KAAM;YACpB,MAAMZ,QAAQO,KAAK,CAACJ,IAAI;YAExB,IAAID,aAAaC,MAAM;gBACnB,IAAIF,MAAM,OAAO,CAACD,QACdW,GAAG,CAACR,IAAI,GAAGH,MAAM,MAAM,CAACD,eAAe,GAAG,CAACe,CAAAA,QAChC,IAAI,CAAC,QAAQ,CAAC;wBACjB,OAAOA;wBACPJ;oBACJ;gBAGR;YACJ;YAAO,IAAIA,QAAQP,MAAM;gBACrB,IAAI,CAACQ,IAAI,MAAM,EACXA,IAAI,MAAM,GAAG,CAAC;gBAElBA,IAAI,MAAM,CAACR,IAAI,GAAGH;gBAClB;YACJ;YAEAW,GAAG,CAACR,IAAI,GAAGH;QACf;QAEA,OAAOW;IACX;AACJ;AAEO,MAAMI,cAAcC,eAAe,oBAAoB,CAAC;IAC3D,gBAAgBZ;IAChB,cAAc,EAAE;AACpB"}

package/features/whereMapper/abstractions.d.ts

@@ -0,0 +1,15 @@
+import type { CmsEntryListWhere, CmsModelField } from "../../types/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface ICmsWhereMapperParams<T extends GenericRecord> {
+    fields: Pick<CmsModelField, "fieldId">[];
+    input: T | undefined;
+}
+export interface ICmsWhereMapper {
+    map<T extends GenericRecord>(params: ICmsWhereMapperParams<T>): CmsEntryListWhere | undefined;
+}
+/** Map CMS filter conditions to storage queries. */
+export declare const CmsWhereMapper: import("@webiny/di").Abstraction<ICmsWhereMapper>;
+export declare namespace CmsWhereMapper {
+    type Interface = ICmsWhereMapper;
+    type Params<T extends GenericRecord> = ICmsWhereMapperParams<T>;
+}

package/features/whereMapper/abstractions.js

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

package/features/whereMapper/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/whereMapper/abstractions.js","sources":["../../../src/features/whereMapper/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsEntryListWhere, CmsModelField } from \"~/types/index.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface ICmsWhereMapperParams<T extends GenericRecord> {\n    fields: Pick<CmsModelField, \"fieldId\">[];\n    input: T | undefined;\n}\n\nexport interface ICmsWhereMapper {\n    map<T extends GenericRecord>(params: ICmsWhereMapperParams<T>): CmsEntryListWhere | undefined;\n}\n\n/** Map CMS filter conditions to storage queries. */\nexport const CmsWhereMapper = createAbstraction<ICmsWhereMapper>(\"CmsWhereMapper\");\n\nexport namespace CmsWhereMapper {\n    export type Interface = ICmsWhereMapper;\n    export type Params<T extends GenericRecord> = ICmsWhereMapperParams<T>;\n}\n"],"names":["CmsWhereMapper","createAbstraction"],"mappings":";AAcO,MAAMA,iBAAiBC,kBAAmC"}

package/features/whereMapper/feature.d.ts

@@ -0,0 +1,6 @@
+export type { ICmsWhereMapperParams, ICmsWhereMapper } from "./abstractions.js";
+export { CmsWhereMapper } from "./abstractions.js";
+export declare const CmsWhereMapperFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/whereMapper/feature.js

@@ -0,0 +1,12 @@
+import { createFeature } from "@webiny/feature/api";
+import { WhereMapper } from "./WhereMapper.js";
+const CmsWhereMapperFeature = createFeature({
+    name: "CmsWhereMapper",
+    register (container) {
+        container.register(WhereMapper).inSingletonScope();
+    }
+});
+export { CmsWhereMapper } from "./abstractions.js";
+export { CmsWhereMapperFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/whereMapper/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/whereMapper/feature.js","sources":["../../../src/features/whereMapper/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { WhereMapper } from \"./WhereMapper.js\";\n\nexport type { ICmsWhereMapperParams, ICmsWhereMapper } from \"./abstractions.js\";\n\nexport { CmsWhereMapper } from \"./abstractions.js\";\n\nexport const CmsWhereMapperFeature = createFeature({\n    name: \"CmsWhereMapper\",\n    register(container) {\n        container.register(WhereMapper).inSingletonScope();\n    }\n});\n"],"names":["CmsWhereMapperFeature","createFeature","container","WhereMapper"],"mappings":";;AAOO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,aAAa,gBAAgB;IACpD;AACJ"}