@webiny/app-headless-cms 0.0.0-unstable.496cf268ac → 0.0.0-unstable.5387e5f7c8

package/features/contentEntry/duplicateEntry/DuplicateEntryGateway.d.ts

@@ -0,0 +1,14 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsContentEntry } from "../../../types.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { DuplicateEntryGateway as GatewayAbstraction, type IDuplicateEntryParams } from "./abstractions.js";
+declare class DuplicateEntryGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    private fields;
+    constructor(client: CmsGraphQLClient.Interface, fields: EntryGraphQLFields.Interface);
+    execute({ model, revisionId }: IDuplicateEntryParams): Promise<CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const DuplicateEntryGateway: typeof DuplicateEntryGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDuplicateEntryGateway>;
+};
+export {};

package/features/contentEntry/duplicateEntry/DuplicateEntryGateway.js

@@ -0,0 +1,43 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { DuplicateEntryGateway } from "./abstractions.js";
+function createMutation(model, fields) {
+    return `
+        mutation CmsEntriesDuplicate${model.singularApiName}($revision: ID!) {
+            content: duplicate${model.singularApiName}(revision: $revision) {
+                data {
+                    ${fields.getSystemFields(model)}
+                    ${fields.getValuesBlock(model)}
+                }
+                error { message code data }
+            }
+        }
+    `;
+}
+class DuplicateEntryGatewayImpl {
+    constructor(client, fields){
+        this.client = client;
+        this.fields = fields;
+    }
+    async execute({ model, revisionId }) {
+        const response = await this.client.execute({
+            query: createMutation(model, this.fields),
+            variables: {
+                revision: revisionId
+            }
+        });
+        const { data: entry, error } = response.content;
+        if (!entry) throw new Error(error?.message || "Could not duplicate entry");
+        return entry;
+    }
+}
+const DuplicateEntryGateway_DuplicateEntryGateway = DuplicateEntryGateway.createImplementation({
+    implementation: DuplicateEntryGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient,
+        EntryGraphQLFields
+    ]
+});
+export { DuplicateEntryGateway_DuplicateEntryGateway as DuplicateEntryGateway };
+
+//# sourceMappingURL=DuplicateEntryGateway.js.map

package/features/contentEntry/duplicateEntry/DuplicateEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/duplicateEntry/DuplicateEntryGateway.js","sources":["../../../../src/features/contentEntry/duplicateEntry/DuplicateEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsContentEntry, CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport { EntryGraphQLFields } from \"../abstractions.js\";\nimport {\n    DuplicateEntryGateway as GatewayAbstraction,\n    type IDuplicateEntryParams\n} from \"./abstractions.js\";\n\ninterface DuplicateEntryResponse {\n    content: {\n        data: CmsContentEntry | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\nfunction createMutation(model: CmsModel, fields: EntryGraphQLFields.Interface) {\n    return /* GraphQL */ `\n        mutation CmsEntriesDuplicate${model.singularApiName}($revision: ID!) {\n            content: duplicate${model.singularApiName}(revision: $revision) {\n                data {\n                    ${fields.getSystemFields(model)}\n                    ${fields.getValuesBlock(model)}\n                }\n                error { message code data }\n            }\n        }\n    `;\n}\n\nclass DuplicateEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: CmsGraphQLClient.Interface,\n        private fields: EntryGraphQLFields.Interface\n    ) {}\n\n    async execute({ model, revisionId }: IDuplicateEntryParams) {\n        const response = await this.client.execute<DuplicateEntryResponse>({\n            query: createMutation(model, this.fields),\n            variables: { revision: revisionId }\n        });\n\n        const { data: entry, error } = response.content;\n\n        if (!entry) {\n            throw new Error(error?.message || \"Could not duplicate entry\");\n        }\n\n        return entry;\n    }\n}\n\nexport const DuplicateEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: DuplicateEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient, EntryGraphQLFields]\n});\n"],"names":["createMutation","model","fields","DuplicateEntryGatewayImpl","client","revisionId","response","entry","error","Error","DuplicateEntryGateway","GatewayAbstraction","CmsGraphQLClient","EntryGraphQLFields"],"mappings":";;;AAeA,SAASA,eAAeC,KAAe,EAAEC,MAAoC;IACzE,OAAqB,CAAC;oCACU,EAAED,MAAM,eAAe,CAAC;8BAC9B,EAAEA,MAAM,eAAe,CAAC;;oBAElC,EAAEC,OAAO,eAAe,CAACD,OAAO;oBAChC,EAAEC,OAAO,cAAc,CAACD,OAAO;;;;;IAK/C,CAAC;AACL;AAEA,MAAME;IACF,YACYC,MAAkC,EAClCF,MAAoC,CAC9C;aAFUE,MAAM,GAANA;aACAF,MAAM,GAANA;IACT;IAEH,MAAM,QAAQ,EAAED,KAAK,EAAEI,UAAU,EAAyB,EAAE;QACxD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAyB;YAC/D,OAAON,eAAeC,OAAO,IAAI,CAAC,MAAM;YACxC,WAAW;gBAAE,UAAUI;YAAW;QACtC;QAEA,MAAM,EAAE,MAAME,KAAK,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAE/C,IAAI,CAACC,OACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,8CAAwBC,sBAAAA,oBAAuC,CAAC;IACzE,gBAAgBR;IAChB,cAAc;QAACS;QAAkBC;KAAmB;AACxD"}

package/features/contentEntry/duplicateEntry/DuplicateEntryRepository.d.ts

@@ -0,0 +1,15 @@
+import { DuplicateEntryRepository as RepositoryAbstraction, DuplicateEntryGateway } from "./abstractions.js";
+import type { IDuplicateEntryParams } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../../../features/contentEntry/abstractions.js";
+import { EventPublisher } from "@webiny/app/features/eventPublisher/index.js";
+declare class DuplicateEntryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cacheProvider;
+    private gateway;
+    private eventPublisher;
+    constructor(cacheProvider: ContentEntriesCacheProvider.Interface, gateway: DuplicateEntryGateway.Interface, eventPublisher: EventPublisher.Interface);
+    execute(params: IDuplicateEntryParams): Promise<import("@webiny/app-headless-cms-common/types/index.js").CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const DuplicateEntryRepository: typeof DuplicateEntryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDuplicateEntryRepository>;
+};
+export {};

package/features/contentEntry/duplicateEntry/DuplicateEntryRepository.js

@@ -0,0 +1,34 @@
+import { DuplicateEntryGateway, DuplicateEntryRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../abstractions.js";
+import { EventPublisher } from "@webiny/app/features/eventPublisher/index.js";
+import { EntryAfterCreateEvent } from "../events/EntryAfterCreateEvent.js";
+class DuplicateEntryRepositoryImpl {
+    constructor(cacheProvider, gateway, eventPublisher){
+        this.cacheProvider = cacheProvider;
+        this.gateway = gateway;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(params) {
+        const entry = await this.gateway.execute(params);
+        const cache = this.cacheProvider.get(params.model.modelId);
+        cache.addItems([
+            entry
+        ]);
+        await this.eventPublisher.publish(new EntryAfterCreateEvent({
+            entry,
+            model: params.model
+        }));
+        return entry;
+    }
+}
+const DuplicateEntryRepository_DuplicateEntryRepository = DuplicateEntryRepository.createImplementation({
+    implementation: DuplicateEntryRepositoryImpl,
+    dependencies: [
+        ContentEntriesCacheProvider,
+        DuplicateEntryGateway,
+        EventPublisher
+    ]
+});
+export { DuplicateEntryRepository_DuplicateEntryRepository as DuplicateEntryRepository };
+
+//# sourceMappingURL=DuplicateEntryRepository.js.map

package/features/contentEntry/duplicateEntry/DuplicateEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/duplicateEntry/DuplicateEntryRepository.js","sources":["../../../../src/features/contentEntry/duplicateEntry/DuplicateEntryRepository.ts"],"sourcesContent":["import {\n    DuplicateEntryRepository as RepositoryAbstraction,\n    DuplicateEntryGateway\n} from \"./abstractions.js\";\nimport type { IDuplicateEntryParams } from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport { EventPublisher } from \"@webiny/app/features/eventPublisher/index.js\";\nimport { EntryAfterCreateEvent } from \"~/features/contentEntry/events/EntryAfterCreateEvent.js\";\n\nclass DuplicateEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: DuplicateEntryGateway.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(params: IDuplicateEntryParams) {\n        const entry = await this.gateway.execute(params);\n\n        const cache = this.cacheProvider.get(params.model.modelId);\n        cache.addItems([entry]);\n\n        // Duplicating results in a brand-new entry, so we notify the same listeners as on create.\n        await this.eventPublisher.publish(\n            new EntryAfterCreateEvent({ entry, model: params.model })\n        );\n\n        return entry;\n    }\n}\n\nexport const DuplicateEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: DuplicateEntryRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, DuplicateEntryGateway, EventPublisher]\n});\n"],"names":["DuplicateEntryRepositoryImpl","cacheProvider","gateway","eventPublisher","params","entry","cache","EntryAfterCreateEvent","DuplicateEntryRepository","RepositoryAbstraction","ContentEntriesCacheProvider","DuplicateEntryGateway","EventPublisher"],"mappings":";;;;AASA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAAwC,EACxCC,cAAwC,CAClD;aAHUF,aAAa,GAAbA;aACAC,OAAO,GAAPA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,MAA6B,EAAE;QACzC,MAAMC,QAAQ,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QAEzC,MAAME,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAACF,OAAO,KAAK,CAAC,OAAO;QACzDE,MAAM,QAAQ,CAAC;YAACD;SAAM;QAGtB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,sBAAsB;YAAEF;YAAO,OAAOD,OAAO,KAAK;QAAC;QAG3D,OAAOC;IACX;AACJ;AAEO,MAAMG,oDAA2BC,yBAAAA,oBAA0C,CAAC;IAC/E,gBAAgBT;IAChB,cAAc;QAACU;QAA6BC;QAAuBC;KAAe;AACtF"}

package/features/contentEntry/duplicateEntry/DuplicateEntryUseCase.d.ts

@@ -0,0 +1,11 @@
+import { DuplicateEntryUseCase as UseCaseAbstraction, DuplicateEntryRepository } from "./abstractions.js";
+import type { IDuplicateEntryParams } from "./abstractions.js";
+declare class DuplicateEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: DuplicateEntryRepository.Interface);
+    execute(params: IDuplicateEntryParams): Promise<import("@webiny/app-headless-cms-common/types/index.js").CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const DuplicateEntryUseCase: typeof DuplicateEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDuplicateEntryUseCase>;
+};
+export {};

package/features/contentEntry/duplicateEntry/DuplicateEntryUseCase.js

@@ -0,0 +1,18 @@
+import { DuplicateEntryRepository, DuplicateEntryUseCase } from "./abstractions.js";
+class DuplicateEntryUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(params) {
+        return this.repository.execute(params);
+    }
+}
+const DuplicateEntryUseCase_DuplicateEntryUseCase = DuplicateEntryUseCase.createImplementation({
+    implementation: DuplicateEntryUseCaseImpl,
+    dependencies: [
+        DuplicateEntryRepository
+    ]
+});
+export { DuplicateEntryUseCase_DuplicateEntryUseCase as DuplicateEntryUseCase };
+
+//# sourceMappingURL=DuplicateEntryUseCase.js.map

package/features/contentEntry/duplicateEntry/DuplicateEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/duplicateEntry/DuplicateEntryUseCase.js","sources":["../../../../src/features/contentEntry/duplicateEntry/DuplicateEntryUseCase.ts"],"sourcesContent":["import {\n    DuplicateEntryUseCase as UseCaseAbstraction,\n    DuplicateEntryRepository\n} from \"./abstractions.js\";\nimport type { IDuplicateEntryParams } from \"./abstractions.js\";\n\nclass DuplicateEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: DuplicateEntryRepository.Interface) {}\n\n    async execute(params: IDuplicateEntryParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const DuplicateEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DuplicateEntryUseCaseImpl,\n    dependencies: [DuplicateEntryRepository]\n});\n"],"names":["DuplicateEntryUseCaseImpl","repository","params","DuplicateEntryUseCase","UseCaseAbstraction","DuplicateEntryRepository"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,UAA8C,CAAE;aAAhDA,UAAU,GAAVA;IAAiD;IAErE,MAAM,QAAQC,MAA6B,EAAE;QACzC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAAuC,CAAC;IACzE,gBAAgBJ;IAChB,cAAc;QAACK;KAAyB;AAC5C"}

package/features/contentEntry/duplicateEntry/abstractions.d.ts

@@ -0,0 +1,26 @@
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface IDuplicateEntryParams {
+    model: CmsModel;
+    revisionId: string;
+}
+export interface IDuplicateEntryGateway {
+    execute(params: IDuplicateEntryParams): Promise<CmsContentEntry>;
+}
+export declare const DuplicateEntryGateway: import("@webiny/di").Abstraction<IDuplicateEntryGateway>;
+export declare namespace DuplicateEntryGateway {
+    type Interface = IDuplicateEntryGateway;
+}
+export interface IDuplicateEntryRepository {
+    execute(params: IDuplicateEntryParams): Promise<CmsContentEntry>;
+}
+export declare const DuplicateEntryRepository: import("@webiny/di").Abstraction<IDuplicateEntryRepository>;
+export declare namespace DuplicateEntryRepository {
+    type Interface = IDuplicateEntryRepository;
+}
+export interface IDuplicateEntryUseCase {
+    execute(params: IDuplicateEntryParams): Promise<CmsContentEntry>;
+}
+export declare const DuplicateEntryUseCase: import("@webiny/di").Abstraction<IDuplicateEntryUseCase>;
+export declare namespace DuplicateEntryUseCase {
+    type Interface = IDuplicateEntryUseCase;
+}

package/features/contentEntry/duplicateEntry/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const DuplicateEntryGateway = createAbstraction("DuplicateEntryGateway");
+const DuplicateEntryRepository = createAbstraction("DuplicateEntryRepository");
+const DuplicateEntryUseCase = createAbstraction("DuplicateEntryUseCase");
+export { DuplicateEntryGateway, DuplicateEntryRepository, DuplicateEntryUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/contentEntry/duplicateEntry/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/duplicateEntry/abstractions.js","sources":["../../../../src/features/contentEntry/duplicateEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\nexport interface IDuplicateEntryParams {\n    model: CmsModel;\n    revisionId: string;\n}\n\n// Gateway\n\nexport interface IDuplicateEntryGateway {\n    execute(params: IDuplicateEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const DuplicateEntryGateway =\n    createAbstraction<IDuplicateEntryGateway>(\"DuplicateEntryGateway\");\n\nexport namespace DuplicateEntryGateway {\n    export type Interface = IDuplicateEntryGateway;\n}\n\n// Repository\n\nexport interface IDuplicateEntryRepository {\n    execute(params: IDuplicateEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const DuplicateEntryRepository = createAbstraction<IDuplicateEntryRepository>(\n    \"DuplicateEntryRepository\"\n);\n\nexport namespace DuplicateEntryRepository {\n    export type Interface = IDuplicateEntryRepository;\n}\n\n// UseCase\n\nexport interface IDuplicateEntryUseCase {\n    execute(params: IDuplicateEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const DuplicateEntryUseCase =\n    createAbstraction<IDuplicateEntryUseCase>(\"DuplicateEntryUseCase\");\n\nexport namespace DuplicateEntryUseCase {\n    export type Interface = IDuplicateEntryUseCase;\n}\n"],"names":["DuplicateEntryGateway","createAbstraction","DuplicateEntryRepository","DuplicateEntryUseCase"],"mappings":";AAcO,MAAMA,wBACTC,kBAA0C;AAYvC,MAAMC,2BAA2BD,kBACpC;AAaG,MAAME,wBACTF,kBAA0C"}

package/features/contentEntry/duplicateEntry/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const DuplicateEntryFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    useCase: import("./abstractions.js").IDuplicateEntryUseCase;
+}, []>;

package/features/contentEntry/duplicateEntry/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { DuplicateEntryUseCase } from "./abstractions.js";
+import { DuplicateEntryUseCase as external_DuplicateEntryUseCase_js_DuplicateEntryUseCase } from "./DuplicateEntryUseCase.js";
+import { DuplicateEntryRepository } from "./DuplicateEntryRepository.js";
+import { DuplicateEntryGateway } from "./DuplicateEntryGateway.js";
+const DuplicateEntryFeature = createFeature({
+    name: "CmsContentEntry/DuplicateEntry",
+    register (container) {
+        container.register(external_DuplicateEntryUseCase_js_DuplicateEntryUseCase);
+        container.register(DuplicateEntryRepository).inSingletonScope();
+        container.register(DuplicateEntryGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(DuplicateEntryUseCase)
+        };
+    }
+});
+export { DuplicateEntryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/contentEntry/duplicateEntry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/duplicateEntry/feature.js","sources":["../../../../src/features/contentEntry/duplicateEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { DuplicateEntryUseCase as UseCase } from \"./abstractions.js\";\nimport { DuplicateEntryUseCase } from \"./DuplicateEntryUseCase.js\";\nimport { DuplicateEntryRepository } from \"./DuplicateEntryRepository.js\";\nimport { DuplicateEntryGateway } from \"./DuplicateEntryGateway.js\";\n\nexport const DuplicateEntryFeature = createFeature({\n    name: \"CmsContentEntry/DuplicateEntry\",\n    register(container) {\n        container.register(DuplicateEntryUseCase);\n        container.register(DuplicateEntryRepository).inSingletonScope();\n        container.register(DuplicateEntryGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["DuplicateEntryFeature","createFeature","container","DuplicateEntryUseCase","DuplicateEntryRepository","DuplicateEntryGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,0BAA0B,gBAAgB;QAC7DF,UAAU,QAAQ,CAACG,uBAAuB,gBAAgB;IAC9D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/contentEntry/entryValueGateways.test.d.ts

@@ -0,0 +1 @@
+export {};

package/features/contentEntry/entryValueGateways.test.js

@@ -0,0 +1,106 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Container } from "@webiny/di";
+import { CmsGraphQLClient } from "../graphQLClient/abstractions.js";
+import { EntryGraphQLFields } from "./abstractions.js";
+import { ValueTransformersFeature } from "./valueTransformers/feature.js";
+import { formValues, graphQLInputValues, pageModel } from "./valueTransformers/entryValueFixtures.js";
+import { CreateEntryGateway } from "./createEntry/abstractions.js";
+import { CreateEntryGateway as CreateEntryGateway_js_CreateEntryGateway } from "./createEntry/CreateEntryGateway.js";
+import { UpdateEntryGateway } from "./updateEntry/abstractions.js";
+import { UpdateEntryGateway as UpdateEntryGateway_js_UpdateEntryGateway } from "./updateEntry/UpdateEntryGateway.js";
+import { UpdateSingletonEntryGateway } from "./singletonEntry/abstractions.js";
+import { UpdateSingletonEntryGateway as UpdateSingletonEntryGateway_js_UpdateSingletonEntryGateway } from "./singletonEntry/UpdateSingletonEntryGateway.js";
+import { CreateRevisionFromGateway } from "./createRevisionFrom/abstractions.js";
+import { CreateRevisionFromGateway as CreateRevisionFromGateway_js_CreateRevisionFromGateway } from "./createRevisionFrom/CreateRevisionFromGateway.js";
+const ENTRY = {
+    id: "entry-1#0001",
+    entryId: "entry-1",
+    values: {}
+};
+const cases = [
+    {
+        name: "CreateEntryGateway",
+        register: (container)=>container.register(CreateEntryGateway_js_CreateEntryGateway),
+        execute: (container, data)=>container.resolve(CreateEntryGateway).execute({
+                model: pageModel,
+                data
+            })
+    },
+    {
+        name: "UpdateEntryGateway",
+        register: (container)=>container.register(UpdateEntryGateway_js_UpdateEntryGateway),
+        execute: (container, data)=>container.resolve(UpdateEntryGateway).execute({
+                model: pageModel,
+                revisionId: ENTRY.id,
+                data
+            })
+    },
+    {
+        name: "UpdateSingletonEntryGateway",
+        register: (container)=>container.register(UpdateSingletonEntryGateway_js_UpdateSingletonEntryGateway),
+        execute: (container, data)=>container.resolve(UpdateSingletonEntryGateway).execute({
+                model: pageModel,
+                data
+            })
+    },
+    {
+        name: "CreateRevisionFromGateway",
+        register: (container)=>container.register(CreateRevisionFromGateway_js_CreateRevisionFromGateway),
+        execute: (container, data)=>container.resolve(CreateRevisionFromGateway).execute({
+                model: pageModel,
+                revisionId: ENTRY.id,
+                data
+            })
+    }
+];
+describe.each(cases)("$name", ({ register, execute })=>{
+    let container;
+    let client;
+    beforeEach(()=>{
+        container = new Container();
+        client = {
+            execute: vi.fn().mockResolvedValue({
+                content: {
+                    data: ENTRY,
+                    error: null
+                }
+            })
+        };
+        ValueTransformersFeature.register(container);
+        container.registerInstance(CmsGraphQLClient, client);
+        container.registerInstance(EntryGraphQLFields, {
+            getSystemFields: ()=>"id",
+            getValuesBlock: ()=>""
+        });
+        register(container);
+    });
+    it("should send dynamic zone values in the GraphQL input shape", async ()=>{
+        await execute(container, {
+            values: formValues
+        });
+        expect(client.execute).toHaveBeenCalledTimes(1);
+        const { variables } = client.execute.mock.calls[0][0];
+        expect(variables.data).toEqual({
+            values: graphQLInputValues
+        });
+    });
+    it("should keep keys other than values in the payload", async ()=>{
+        await execute(container, {
+            values: formValues,
+            wbyAco_location: {
+                folderId: "root"
+            }
+        });
+        const { variables } = client.execute.mock.calls[0][0];
+        expect(variables.data.wbyAco_location).toEqual({
+            folderId: "root"
+        });
+    });
+    it("should return the entry from the API response", async ()=>{
+        await expect(execute(container, {
+            values: formValues
+        })).resolves.toEqual(ENTRY);
+    });
+});
+
+//# sourceMappingURL=entryValueGateways.test.js.map

package/features/contentEntry/entryValueGateways.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryValueGateways.test.js","sources":["../../../src/features/contentEntry/entryValueGateways.test.ts"],"sourcesContent":["import { describe, it, expect, vi, beforeEach } from \"vitest\";\nimport { Container } from \"@webiny/di\";\nimport type { CmsContentEntry } from \"~/types.js\";\nimport { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport { EntryGraphQLFields } from \"./abstractions.js\";\nimport { ValueTransformersFeature } from \"./valueTransformers/feature.js\";\nimport {\n    formValues,\n    graphQLInputValues,\n    pageModel\n} from \"./valueTransformers/entryValueFixtures.js\";\nimport { CreateEntryGateway as CreateEntryGatewayAbstraction } from \"./createEntry/abstractions.js\";\nimport { CreateEntryGateway } from \"./createEntry/CreateEntryGateway.js\";\nimport { UpdateEntryGateway as UpdateEntryGatewayAbstraction } from \"./updateEntry/abstractions.js\";\nimport { UpdateEntryGateway } from \"./updateEntry/UpdateEntryGateway.js\";\nimport { UpdateSingletonEntryGateway as UpdateSingletonEntryGatewayAbstraction } from \"./singletonEntry/abstractions.js\";\nimport { UpdateSingletonEntryGateway } from \"./singletonEntry/UpdateSingletonEntryGateway.js\";\nimport { CreateRevisionFromGateway as CreateRevisionFromGatewayAbstraction } from \"./createRevisionFrom/abstractions.js\";\nimport { CreateRevisionFromGateway } from \"./createRevisionFrom/CreateRevisionFromGateway.js\";\n\n/**\n * Every gateway that sends entry values to the API must convert them from the form\n * shape into the GraphQL input shape. A gateway that skips this step breaks saving\n * entries with dynamic zone fields (\"Field ... is not defined by type <Model>_<Field>Input\").\n *\n * When you add a new gateway that sends entry values, add it to this list.\n */\n\nconst ENTRY = { id: \"entry-1#0001\", entryId: \"entry-1\", values: {} } as unknown as CmsContentEntry;\n\ninterface GatewayCase {\n    name: string;\n    register: (container: Container) => void;\n    execute: (container: Container, data: Record<string, unknown>) => Promise<unknown>;\n}\n\nconst cases: GatewayCase[] = [\n    {\n        name: \"CreateEntryGateway\",\n        register: container => container.register(CreateEntryGateway),\n        execute: (container, data) =>\n            container.resolve(CreateEntryGatewayAbstraction).execute({ model: pageModel, data })\n    },\n    {\n        name: \"UpdateEntryGateway\",\n        register: container => container.register(UpdateEntryGateway),\n        execute: (container, data) =>\n            container\n                .resolve(UpdateEntryGatewayAbstraction)\n                .execute({ model: pageModel, revisionId: ENTRY.id, data })\n    },\n    {\n        name: \"UpdateSingletonEntryGateway\",\n        register: container => container.register(UpdateSingletonEntryGateway),\n        execute: (container, data) =>\n            container\n                .resolve(UpdateSingletonEntryGatewayAbstraction)\n                .execute({ model: pageModel, data })\n    },\n    {\n        name: \"CreateRevisionFromGateway\",\n        register: container => container.register(CreateRevisionFromGateway),\n        execute: (container, data) =>\n            container\n                .resolve(CreateRevisionFromGatewayAbstraction)\n                .execute({ model: pageModel, revisionId: ENTRY.id, data })\n    }\n];\n\ndescribe.each(cases)(\"$name\", ({ register, execute }) => {\n    let container: Container;\n    let client: { execute: ReturnType<typeof vi.fn> };\n\n    beforeEach(() => {\n        container = new Container();\n        client = {\n            execute: vi.fn().mockResolvedValue({ content: { data: ENTRY, error: null } })\n        };\n\n        ValueTransformersFeature.register(container);\n        container.registerInstance(\n            CmsGraphQLClient,\n            client as unknown as CmsGraphQLClient.Interface\n        );\n        container.registerInstance(EntryGraphQLFields, {\n            getSystemFields: () => \"id\",\n            getValuesBlock: () => \"\"\n        } as unknown as EntryGraphQLFields.Interface);\n        register(container);\n    });\n\n    it(\"should send dynamic zone values in the GraphQL input shape\", async () => {\n        await execute(container, { values: formValues });\n\n        expect(client.execute).toHaveBeenCalledTimes(1);\n        const { variables } = client.execute.mock.calls[0][0];\n        expect(variables.data).toEqual({ values: graphQLInputValues });\n    });\n\n    it(\"should keep keys other than values in the payload\", async () => {\n        await execute(container, {\n            values: formValues,\n            wbyAco_location: { folderId: \"root\" }\n        });\n\n        const { variables } = client.execute.mock.calls[0][0];\n        expect(variables.data.wbyAco_location).toEqual({ folderId: \"root\" });\n    });\n\n    it(\"should return the entry from the API response\", async () => {\n        await expect(execute(container, { values: formValues })).resolves.toEqual(ENTRY);\n    });\n});\n"],"names":["ENTRY","cases","container","CreateEntryGateway","data","CreateEntryGatewayAbstraction","pageModel","UpdateEntryGateway","UpdateEntryGatewayAbstraction","UpdateSingletonEntryGateway","UpdateSingletonEntryGatewayAbstraction","CreateRevisionFromGateway","CreateRevisionFromGatewayAbstraction","describe","register","execute","client","beforeEach","Container","vi","ValueTransformersFeature","CmsGraphQLClient","EntryGraphQLFields","it","formValues","expect","variables","graphQLInputValues"],"mappings":";;;;;;;;;;;;;;AA4BA,MAAMA,QAAQ;IAAE,IAAI;IAAgB,SAAS;IAAW,QAAQ,CAAC;AAAE;AAQnE,MAAMC,QAAuB;IACzB;QACI,MAAM;QACN,UAAUC,CAAAA,YAAaA,UAAU,QAAQ,CAACC;QAC1C,SAAS,CAACD,WAAWE,OACjBF,UAAU,OAAO,CAACG,oBAA+B,OAAO,CAAC;gBAAE,OAAOC;gBAAWF;YAAK;IAC1F;IACA;QACI,MAAM;QACN,UAAUF,CAAAA,YAAaA,UAAU,QAAQ,CAACK;QAC1C,SAAS,CAACL,WAAWE,OACjBF,UACK,OAAO,CAACM,oBACR,OAAO,CAAC;gBAAE,OAAOF;gBAAW,YAAYN,MAAM,EAAE;gBAAEI;YAAK;IACpE;IACA;QACI,MAAM;QACN,UAAUF,CAAAA,YAAaA,UAAU,QAAQ,CAACO;QAC1C,SAAS,CAACP,WAAWE,OACjBF,UACK,OAAO,CAACQ,6BACR,OAAO,CAAC;gBAAE,OAAOJ;gBAAWF;YAAK;IAC9C;IACA;QACI,MAAM;QACN,UAAUF,CAAAA,YAAaA,UAAU,QAAQ,CAACS;QAC1C,SAAS,CAACT,WAAWE,OACjBF,UACK,OAAO,CAACU,2BACR,OAAO,CAAC;gBAAE,OAAON;gBAAW,YAAYN,MAAM,EAAE;gBAAEI;YAAK;IACpE;CACH;AAEDS,SAAS,IAAI,CAACZ,OAAO,SAAS,CAAC,EAAEa,QAAQ,EAAEC,OAAO,EAAE;IAChD,IAAIb;IACJ,IAAIc;IAEJC,WAAW;QACPf,YAAY,IAAIgB;QAChBF,SAAS;YACL,SAASG,GAAG,EAAE,GAAG,iBAAiB,CAAC;gBAAE,SAAS;oBAAE,MAAMnB;oBAAO,OAAO;gBAAK;YAAE;QAC/E;QAEAoB,yBAAyB,QAAQ,CAAClB;QAClCA,UAAU,gBAAgB,CACtBmB,kBACAL;QAEJd,UAAU,gBAAgB,CAACoB,oBAAoB;YAC3C,iBAAiB,IAAM;YACvB,gBAAgB,IAAM;QAC1B;QACAR,SAASZ;IACb;IAEAqB,GAAG,8DAA8D;QAC7D,MAAMR,QAAQb,WAAW;YAAE,QAAQsB;QAAW;QAE9CC,OAAOT,OAAO,OAAO,EAAE,qBAAqB,CAAC;QAC7C,MAAM,EAAEU,SAAS,EAAE,GAAGV,OAAO,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;QACrDS,OAAOC,UAAU,IAAI,EAAE,OAAO,CAAC;YAAE,QAAQC;QAAmB;IAChE;IAEAJ,GAAG,qDAAqD;QACpD,MAAMR,QAAQb,WAAW;YACrB,QAAQsB;YACR,iBAAiB;gBAAE,UAAU;YAAO;QACxC;QAEA,MAAM,EAAEE,SAAS,EAAE,GAAGV,OAAO,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;QACrDS,OAAOC,UAAU,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC;YAAE,UAAU;QAAO;IACtE;IAEAH,GAAG,iDAAiD;QAChD,MAAME,OAAOV,QAAQb,WAAW;YAAE,QAAQsB;QAAW,IAAI,QAAQ,CAAC,OAAO,CAACxB;IAC9E;AACJ"}

package/features/contentEntry/events/EntryAfterCreateEvent.d.ts

@@ -0,0 +1,10 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface EntryAfterCreatePayload {
+    entry: CmsContentEntry;
+    model: CmsModel;
+}
+export declare class EntryAfterCreateEvent extends BaseEvent<EntryAfterCreatePayload> {
+    readonly eventType: "Cms/Entry/AfterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<EntryAfterCreateEvent>>;
+}

package/features/contentEntry/events/EntryAfterCreateEvent.js

@@ -0,0 +1,13 @@
+import { EntryAfterCreateEventHandler } from "./abstractions.js";
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+class EntryAfterCreateEvent extends BaseEvent {
+    getHandlerAbstraction() {
+        return EntryAfterCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/AfterCreate";
+    }
+}
+export { EntryAfterCreateEvent };
+
+//# sourceMappingURL=EntryAfterCreateEvent.js.map

package/features/contentEntry/events/EntryAfterCreateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/events/EntryAfterCreateEvent.js","sources":["../../../../src/features/contentEntry/events/EntryAfterCreateEvent.ts"],"sourcesContent":["import { EntryAfterCreateEventHandler } from \"./abstractions.js\";\nimport { BaseEvent } from \"@webiny/app/features/eventPublisher/index.js\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\nexport interface EntryAfterCreatePayload {\n    entry: CmsContentEntry;\n    model: CmsModel;\n}\n\nexport class EntryAfterCreateEvent extends BaseEvent<EntryAfterCreatePayload> {\n    readonly eventType = \"Cms/Entry/AfterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterCreateEventHandler;\n    }\n}\n"],"names":["EntryAfterCreateEvent","BaseEvent","EntryAfterCreateEventHandler"],"mappings":";;AASO,MAAMA,8BAA8BC;IAGvC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACM,SAAS,GAAG;;AAKzB"}

package/features/contentEntry/events/EntryAfterDeleteEvent.d.ts

@@ -0,0 +1,11 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+import type { CmsModel } from "../../../types.js";
+export interface EntryAfterDeletePayload {
+    model: CmsModel;
+    id: string;
+    entryId: string;
+}
+export declare class EntryAfterDeleteEvent extends BaseEvent<EntryAfterDeletePayload> {
+    readonly eventType: "Cms/Entry/AfterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<EntryAfterDeleteEvent>>;
+}

package/features/contentEntry/events/EntryAfterDeleteEvent.js

@@ -0,0 +1,13 @@
+import { EntryAfterDeleteEventHandler } from "./abstractions.js";
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+class EntryAfterDeleteEvent extends BaseEvent {
+    getHandlerAbstraction() {
+        return EntryAfterDeleteEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/AfterDelete";
+    }
+}
+export { EntryAfterDeleteEvent };
+
+//# sourceMappingURL=EntryAfterDeleteEvent.js.map

package/features/contentEntry/events/EntryAfterDeleteEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/events/EntryAfterDeleteEvent.js","sources":["../../../../src/features/contentEntry/events/EntryAfterDeleteEvent.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"./abstractions.js\";\nimport { BaseEvent } from \"@webiny/app/features/eventPublisher/index.js\";\nimport type { CmsModel } from \"~/types.js\";\n\nexport interface EntryAfterDeletePayload {\n    model: CmsModel;\n    id: string;\n    entryId: string;\n}\n\nexport class EntryAfterDeleteEvent extends BaseEvent<EntryAfterDeletePayload> {\n    readonly eventType = \"Cms/Entry/AfterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterDeleteEventHandler;\n    }\n}\n"],"names":["EntryAfterDeleteEvent","BaseEvent","EntryAfterDeleteEventHandler"],"mappings":";;AAUO,MAAMA,8BAA8BC;IAGvC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACM,SAAS,GAAG;;AAKzB"}

package/features/contentEntry/events/EntryAfterUpdateEvent.d.ts

@@ -0,0 +1,10 @@
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface EntryAfterUpdatePayload {
+    entry: CmsContentEntry;
+    model: CmsModel;
+}
+export declare class EntryAfterUpdateEvent extends BaseEvent<EntryAfterUpdatePayload> {
+    readonly eventType: "Cms/Entry/AfterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/app/features/eventPublisher/abstractions.js").IEventHandler<EntryAfterUpdateEvent>>;
+}

package/features/contentEntry/events/EntryAfterUpdateEvent.js

@@ -0,0 +1,13 @@
+import { EntryAfterUpdateEventHandler } from "./abstractions.js";
+import { BaseEvent } from "@webiny/app/features/eventPublisher/index.js";
+class EntryAfterUpdateEvent extends BaseEvent {
+    getHandlerAbstraction() {
+        return EntryAfterUpdateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Entry/AfterUpdate";
+    }
+}
+export { EntryAfterUpdateEvent };
+
+//# sourceMappingURL=EntryAfterUpdateEvent.js.map

package/features/contentEntry/events/EntryAfterUpdateEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/events/EntryAfterUpdateEvent.js","sources":["../../../../src/features/contentEntry/events/EntryAfterUpdateEvent.ts"],"sourcesContent":["import { EntryAfterUpdateEventHandler } from \"./abstractions.js\";\nimport { BaseEvent } from \"@webiny/app/features/eventPublisher/index.js\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\nexport interface EntryAfterUpdatePayload {\n    entry: CmsContentEntry;\n    model: CmsModel;\n}\n\nexport class EntryAfterUpdateEvent extends BaseEvent<EntryAfterUpdatePayload> {\n    readonly eventType = \"Cms/Entry/AfterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return EntryAfterUpdateEventHandler;\n    }\n}\n"],"names":["EntryAfterUpdateEvent","BaseEvent","EntryAfterUpdateEventHandler"],"mappings":";;AASO,MAAMA,8BAA8BC;IAGvC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACM,SAAS,GAAG;;AAKzB"}

package/features/contentEntry/events/abstractions.d.ts

@@ -0,0 +1,19 @@
+import type { EntryAfterCreateEvent } from "./EntryAfterCreateEvent.js";
+import type { EntryAfterUpdateEvent } from "./EntryAfterUpdateEvent.js";
+import type { EntryAfterDeleteEvent } from "./EntryAfterDeleteEvent.js";
+import type { IEventHandler } from "@webiny/app/features/eventPublisher/index.js";
+export declare const EntryAfterCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterCreateEvent>>;
+export declare namespace EntryAfterCreateEventHandler {
+    type Interface = IEventHandler<EntryAfterCreateEvent>;
+    type Event = EntryAfterCreateEvent;
+}
+export declare const EntryAfterUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterUpdateEvent>>;
+export declare namespace EntryAfterUpdateEventHandler {
+    type Interface = IEventHandler<EntryAfterUpdateEvent>;
+    type Event = EntryAfterUpdateEvent;
+}
+export declare const EntryAfterDeleteEventHandler: import("@webiny/di").Abstraction<IEventHandler<EntryAfterDeleteEvent>>;
+export declare namespace EntryAfterDeleteEventHandler {
+    type Interface = IEventHandler<EntryAfterDeleteEvent>;
+    type Event = EntryAfterDeleteEvent;
+}

package/features/contentEntry/events/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const EntryAfterCreateEventHandler = createAbstraction("App/EntryAfterCreateEventHandler");
+const EntryAfterUpdateEventHandler = createAbstraction("App/EntryAfterUpdateEventHandler");
+const EntryAfterDeleteEventHandler = createAbstraction("App/EntryAfterDeleteEventHandler");
+export { EntryAfterCreateEventHandler, EntryAfterDeleteEventHandler, EntryAfterUpdateEventHandler };
+
+//# sourceMappingURL=abstractions.js.map

package/features/contentEntry/events/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/events/abstractions.js","sources":["../../../../src/features/contentEntry/events/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { EntryAfterCreateEvent } from \"./EntryAfterCreateEvent.js\";\nimport type { EntryAfterUpdateEvent } from \"./EntryAfterUpdateEvent.js\";\nimport type { EntryAfterDeleteEvent } from \"./EntryAfterDeleteEvent.js\";\nimport type { IEventHandler } from \"@webiny/app/features/eventPublisher/index.js\";\n\nexport const EntryAfterCreateEventHandler = createAbstraction<IEventHandler<EntryAfterCreateEvent>>(\n    \"App/EntryAfterCreateEventHandler\"\n);\n\nexport namespace EntryAfterCreateEventHandler {\n    export type Interface = IEventHandler<EntryAfterCreateEvent>;\n    export type Event = EntryAfterCreateEvent;\n}\n\nexport const EntryAfterUpdateEventHandler = createAbstraction<IEventHandler<EntryAfterUpdateEvent>>(\n    \"App/EntryAfterUpdateEventHandler\"\n);\n\nexport namespace EntryAfterUpdateEventHandler {\n    export type Interface = IEventHandler<EntryAfterUpdateEvent>;\n    export type Event = EntryAfterUpdateEvent;\n}\n\nexport const EntryAfterDeleteEventHandler = createAbstraction<IEventHandler<EntryAfterDeleteEvent>>(\n    \"App/EntryAfterDeleteEventHandler\"\n);\n\nexport namespace EntryAfterDeleteEventHandler {\n    export type Interface = IEventHandler<EntryAfterDeleteEvent>;\n    export type Event = EntryAfterDeleteEvent;\n}\n"],"names":["EntryAfterCreateEventHandler","createAbstraction","EntryAfterUpdateEventHandler","EntryAfterDeleteEventHandler"],"mappings":";AAMO,MAAMA,+BAA+BC,kBACxC;AAQG,MAAMC,+BAA+BD,kBACxC;AAQG,MAAME,+BAA+BF,kBACxC"}

package/features/contentEntry/events/index.d.ts

@@ -0,0 +1,7 @@
+export { EntryAfterCreateEvent } from "./EntryAfterCreateEvent.js";
+export type { EntryAfterCreatePayload } from "./EntryAfterCreateEvent.js";
+export { EntryAfterUpdateEvent } from "./EntryAfterUpdateEvent.js";
+export type { EntryAfterUpdatePayload } from "./EntryAfterUpdateEvent.js";
+export { EntryAfterDeleteEvent } from "./EntryAfterDeleteEvent.js";
+export type { EntryAfterDeletePayload } from "./EntryAfterDeleteEvent.js";
+export { EntryAfterCreateEventHandler, EntryAfterUpdateEventHandler, EntryAfterDeleteEventHandler } from "./abstractions.js";

package/features/contentEntry/events/index.js

@@ -0,0 +1,4 @@
+export { EntryAfterCreateEvent } from "./EntryAfterCreateEvent.js";
+export { EntryAfterUpdateEvent } from "./EntryAfterUpdateEvent.js";
+export { EntryAfterDeleteEvent } from "./EntryAfterDeleteEvent.js";
+export { EntryAfterCreateEventHandler, EntryAfterDeleteEventHandler, EntryAfterUpdateEventHandler } from "./abstractions.js";

package/features/contentEntry/feature.d.ts

@@ -0,0 +1 @@
+export declare const ContentEntryFeature: import("@webiny/feature/admin").FeatureDefinition<any, []>;

package/features/contentEntry/feature.js

@@ -0,0 +1,49 @@
+import { createFeature } from "@webiny/feature/admin";
+import { ContentEntriesCacheProvider } from "./ContentEntriesCacheProvider.js";
+import { GetEntryFeature } from "./getEntry/feature.js";
+import { ListEntriesFeature } from "./listEntries/feature.js";
+import { CreateEntryFeature } from "./createEntry/feature.js";
+import { DuplicateEntryFeature } from "./duplicateEntry/feature.js";
+import { UpdateEntryFeature } from "./updateEntry/feature.js";
+import { PublishEntryFeature } from "./publishEntry/feature.js";
+import { UnpublishEntryFeature } from "./unpublishEntry/feature.js";
+import { DeleteEntryFeature } from "./deleteEntry/feature.js";
+import { DeleteEntryRevisionFeature } from "./deleteEntryRevision/feature.js";
+import { CreateRevisionFromFeature } from "./createRevisionFrom/feature.js";
+import { ListRevisionsFeature } from "./listRevisions/feature.js";
+import { UpdateRevisionDescriptionFeature } from "./updateRevisionDescription/feature.js";
+import { SingletonEntryFeature } from "./singletonEntry/feature.js";
+import { MoveEntryFeature } from "./moveEntry/feature.js";
+import { BulkActionFeature } from "./bulkAction/feature.js";
+import { SearchContentEntriesFeature } from "./searchContentEntries/feature.js";
+import { GetContentEntriesFeature } from "./getContentEntries/feature.js";
+import { ValueTransformersFeature } from "./valueTransformers/feature.js";
+import { EntryGraphQLFields } from "./EntryGraphQLFields.js";
+const ContentEntryFeature = createFeature({
+    name: "CmsContentEntry",
+    register (container) {
+        container.register(EntryGraphQLFields).inSingletonScope();
+        container.register(ContentEntriesCacheProvider).inSingletonScope();
+        ValueTransformersFeature.register(container);
+        GetEntryFeature.register(container);
+        ListEntriesFeature.register(container);
+        SearchContentEntriesFeature.register(container);
+        GetContentEntriesFeature.register(container);
+        CreateEntryFeature.register(container);
+        DuplicateEntryFeature.register(container);
+        UpdateEntryFeature.register(container);
+        PublishEntryFeature.register(container);
+        UnpublishEntryFeature.register(container);
+        DeleteEntryFeature.register(container);
+        DeleteEntryRevisionFeature.register(container);
+        CreateRevisionFromFeature.register(container);
+        ListRevisionsFeature.register(container);
+        UpdateRevisionDescriptionFeature.register(container);
+        SingletonEntryFeature.register(container);
+        MoveEntryFeature.register(container);
+        BulkActionFeature.register(container);
+    }
+});
+export { ContentEntryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/contentEntry/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/feature.js","sources":["../../../src/features/contentEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { ContentEntriesCacheProvider } from \"./ContentEntriesCacheProvider.js\";\nimport { GetEntryFeature } from \"./getEntry/feature.js\";\nimport { ListEntriesFeature } from \"./listEntries/feature.js\";\nimport { CreateEntryFeature } from \"./createEntry/feature.js\";\nimport { DuplicateEntryFeature } from \"./duplicateEntry/feature.js\";\nimport { UpdateEntryFeature } from \"./updateEntry/feature.js\";\nimport { PublishEntryFeature } from \"./publishEntry/feature.js\";\nimport { UnpublishEntryFeature } from \"./unpublishEntry/feature.js\";\nimport { DeleteEntryFeature } from \"./deleteEntry/feature.js\";\nimport { DeleteEntryRevisionFeature } from \"./deleteEntryRevision/feature.js\";\nimport { CreateRevisionFromFeature } from \"./createRevisionFrom/feature.js\";\nimport { ListRevisionsFeature } from \"./listRevisions/feature.js\";\nimport { UpdateRevisionDescriptionFeature } from \"./updateRevisionDescription/feature.js\";\nimport { SingletonEntryFeature } from \"./singletonEntry/feature.js\";\nimport { MoveEntryFeature } from \"./moveEntry/feature.js\";\nimport { BulkActionFeature } from \"./bulkAction/feature.js\";\nimport { SearchContentEntriesFeature } from \"./searchContentEntries/feature.js\";\nimport { GetContentEntriesFeature } from \"./getContentEntries/feature.js\";\nimport { ValueTransformersFeature } from \"./valueTransformers/feature.js\";\nimport { EntryGraphQLFields } from \"./EntryGraphQLFields.js\";\n\nexport const ContentEntryFeature = createFeature({\n    name: \"CmsContentEntry\",\n    register(container) {\n        container.register(EntryGraphQLFields).inSingletonScope();\n        container.register(ContentEntriesCacheProvider).inSingletonScope();\n\n        ValueTransformersFeature.register(container);\n        GetEntryFeature.register(container);\n        ListEntriesFeature.register(container);\n        SearchContentEntriesFeature.register(container);\n        GetContentEntriesFeature.register(container);\n        CreateEntryFeature.register(container);\n        DuplicateEntryFeature.register(container);\n        UpdateEntryFeature.register(container);\n        PublishEntryFeature.register(container);\n        UnpublishEntryFeature.register(container);\n        DeleteEntryFeature.register(container);\n        DeleteEntryRevisionFeature.register(container);\n        CreateRevisionFromFeature.register(container);\n        ListRevisionsFeature.register(container);\n        UpdateRevisionDescriptionFeature.register(container);\n        SingletonEntryFeature.register(container);\n        MoveEntryFeature.register(container);\n        BulkActionFeature.register(container);\n    }\n});\n"],"names":["ContentEntryFeature","createFeature","container","EntryGraphQLFields","ContentEntriesCacheProvider","ValueTransformersFeature","GetEntryFeature","ListEntriesFeature","SearchContentEntriesFeature","GetContentEntriesFeature","CreateEntryFeature","DuplicateEntryFeature","UpdateEntryFeature","PublishEntryFeature","UnpublishEntryFeature","DeleteEntryFeature","DeleteEntryRevisionFeature","CreateRevisionFromFeature","ListRevisionsFeature","UpdateRevisionDescriptionFeature","SingletonEntryFeature","MoveEntryFeature","BulkActionFeature"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,oBAAoB,gBAAgB;QACvDD,UAAU,QAAQ,CAACE,6BAA6B,gBAAgB;QAEhEC,yBAAyB,QAAQ,CAACH;QAClCI,gBAAgB,QAAQ,CAACJ;QACzBK,mBAAmB,QAAQ,CAACL;QAC5BM,4BAA4B,QAAQ,CAACN;QACrCO,yBAAyB,QAAQ,CAACP;QAClCQ,mBAAmB,QAAQ,CAACR;QAC5BS,sBAAsB,QAAQ,CAACT;QAC/BU,mBAAmB,QAAQ,CAACV;QAC5BW,oBAAoB,QAAQ,CAACX;QAC7BY,sBAAsB,QAAQ,CAACZ;QAC/Ba,mBAAmB,QAAQ,CAACb;QAC5Bc,2BAA2B,QAAQ,CAACd;QACpCe,0BAA0B,QAAQ,CAACf;QACnCgB,qBAAqB,QAAQ,CAAChB;QAC9BiB,iCAAiC,QAAQ,CAACjB;QAC1CkB,sBAAsB,QAAQ,CAAClB;QAC/BmB,iBAAiB,QAAQ,CAACnB;QAC1BoB,kBAAkB,QAAQ,CAACpB;IAC/B;AACJ"}

package/features/contentEntry/getContentEntries/GetContentEntriesGateway.d.ts

@@ -0,0 +1,11 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import { GetContentEntriesGateway as GatewayAbstraction, type IGetContentEntriesGatewayParams, type IGetContentEntriesGatewayResult } from "./abstractions.js";
+declare class GetContentEntriesGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute(params: IGetContentEntriesGatewayParams): Promise<IGetContentEntriesGatewayResult>;
+}
+export declare const GetContentEntriesGateway: typeof GetContentEntriesGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetContentEntriesGateway>;
+};
+export {};