@webiny/app-headless-cms 6.4.5 → 6.6.0-alpha.0

package/features/contentEntry/createEntry/CreateEntryGateway.d.ts

@@ -0,0 +1,17 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import type { CmsContentEntry } from "../../../types.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { CreateEntryGateway as GatewayAbstraction, type ICreateEntryGatewayParams } from "./abstractions.js";
+import { EntryDataPreparer } from "../../../features/contentEntry/valueTransformers/EntryDataPreparer.js";
+declare class CreateEntryGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    private preparer;
+    private fields;
+    constructor(client: CmsGraphQLClient.Interface, preparer: EntryDataPreparer.Interface, fields: EntryGraphQLFields.Interface);
+    execute({ model, data, options }: ICreateEntryGatewayParams): Promise<CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+    private prepareData;
+}
+export declare const CreateEntryGateway: typeof CreateEntryGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateEntryGateway>;
+};
+export {};

package/features/contentEntry/createEntry/CreateEntryGateway.js

@@ -0,0 +1,56 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { CreateEntryGateway } from "./abstractions.js";
+import { EntryDataPreparer } from "../valueTransformers/EntryDataPreparer.js";
+function createMutation(model, fields) {
+    return `
+        mutation CmsEntriesCreate${model.singularApiName}($data: ${model.singularApiName}Input!, $options: CreateCmsEntryOptionsInput) {
+            content: create${model.singularApiName}(data: $data, options: $options) {
+                data {
+                    ${fields.getSystemFields(model)}
+                    ${fields.getValuesBlock(model)}
+                }
+                error { message code data }
+            }
+        }
+    `;
+}
+class CreateEntryGatewayImpl {
+    constructor(client, preparer, fields){
+        this.client = client;
+        this.preparer = preparer;
+        this.fields = fields;
+    }
+    async execute({ model, data, options }) {
+        const preparedData = this.prepareData(data, model.fields);
+        const response = await this.client.execute({
+            query: createMutation(model, this.fields),
+            variables: {
+                data: preparedData,
+                options
+            }
+        });
+        const { data: entry, error } = response.content;
+        if (!entry) throw new Error(error?.message || "Could not create entry");
+        return entry;
+    }
+    prepareData(data, fields) {
+        const values = data.values;
+        if (!values || "object" != typeof values) return data;
+        return {
+            ...data,
+            values: this.preparer.prepare(values, fields)
+        };
+    }
+}
+const CreateEntryGateway_CreateEntryGateway = CreateEntryGateway.createImplementation({
+    implementation: CreateEntryGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient,
+        EntryDataPreparer,
+        EntryGraphQLFields
+    ]
+});
+export { CreateEntryGateway_CreateEntryGateway as CreateEntryGateway };
+
+//# sourceMappingURL=CreateEntryGateway.js.map

package/features/contentEntry/createEntry/CreateEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createEntry/CreateEntryGateway.js","sources":["../../../../src/features/contentEntry/createEntry/CreateEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsContentEntry, CmsErrorResponse, CmsModel, CmsModelField } from \"~/types.js\";\nimport { EntryGraphQLFields } from \"../abstractions.js\";\nimport {\n    CreateEntryGateway as GatewayAbstraction,\n    type ICreateEntryGatewayParams\n} from \"./abstractions.js\";\nimport { EntryDataPreparer } from \"~/features/contentEntry/valueTransformers/EntryDataPreparer.js\";\n\ninterface CreateEntryResponse {\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 CmsEntriesCreate${model.singularApiName}($data: ${model.singularApiName}Input!, $options: CreateCmsEntryOptionsInput) {\n            content: create${model.singularApiName}(data: $data, options: $options) {\n                data {\n                    ${fields.getSystemFields(model)}\n                    ${fields.getValuesBlock(model)}\n                }\n                error { message code data }\n            }\n        }\n    `;\n}\n\nclass CreateEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: CmsGraphQLClient.Interface,\n        private preparer: EntryDataPreparer.Interface,\n        private fields: EntryGraphQLFields.Interface\n    ) {}\n\n    async execute({ model, data, options }: ICreateEntryGatewayParams) {\n        const preparedData = this.prepareData(data, model.fields);\n\n        const response = await this.client.execute<CreateEntryResponse>({\n            query: createMutation(model, this.fields),\n            variables: { data: preparedData, options }\n        });\n\n        const { data: entry, error } = response.content;\n\n        if (!entry) {\n            throw new Error(error?.message || \"Could not create entry\");\n        }\n\n        return entry;\n    }\n\n    private prepareData(\n        data: Record<string, unknown>,\n        fields: CmsModelField[]\n    ): Record<string, unknown> {\n        const values = data.values;\n        if (!values || typeof values !== \"object\") {\n            return data;\n        }\n        return {\n            ...data,\n            values: this.preparer.prepare(values as Record<string, unknown>, fields)\n        };\n    }\n}\n\nexport const CreateEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: CreateEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient, EntryDataPreparer, EntryGraphQLFields]\n});\n"],"names":["createMutation","model","fields","CreateEntryGatewayImpl","client","preparer","data","options","preparedData","response","entry","error","Error","values","CreateEntryGateway","GatewayAbstraction","CmsGraphQLClient","EntryDataPreparer","EntryGraphQLFields"],"mappings":";;;;AAgBA,SAASA,eAAeC,KAAe,EAAEC,MAAoC;IACzE,OAAqB,CAAC;iCACO,EAAED,MAAM,eAAe,CAAC,QAAQ,EAAEA,MAAM,eAAe,CAAC;2BAC9D,EAAEA,MAAM,eAAe,CAAC;;oBAE/B,EAAEC,OAAO,eAAe,CAACD,OAAO;oBAChC,EAAEC,OAAO,cAAc,CAACD,OAAO;;;;;IAK/C,CAAC;AACL;AAEA,MAAME;IACF,YACYC,MAAkC,EAClCC,QAAqC,EACrCH,MAAoC,CAC9C;aAHUE,MAAM,GAANA;aACAC,QAAQ,GAARA;aACAH,MAAM,GAANA;IACT;IAEH,MAAM,QAAQ,EAAED,KAAK,EAAEK,IAAI,EAAEC,OAAO,EAA6B,EAAE;QAC/D,MAAMC,eAAe,IAAI,CAAC,WAAW,CAACF,MAAML,MAAM,MAAM;QAExD,MAAMQ,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAsB;YAC5D,OAAOT,eAAeC,OAAO,IAAI,CAAC,MAAM;YACxC,WAAW;gBAAE,MAAMO;gBAAcD;YAAQ;QAC7C;QAEA,MAAM,EAAE,MAAMG,KAAK,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAE/C,IAAI,CAACC,OACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;IAEQ,YACJJ,IAA6B,EAC7BJ,MAAuB,EACA;QACvB,MAAMW,SAASP,KAAK,MAAM;QAC1B,IAAI,CAACO,UAAU,AAAkB,YAAlB,OAAOA,QAClB,OAAOP;QAEX,OAAO;YACH,GAAGA,IAAI;YACP,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACO,QAAmCX;QACrE;IACJ;AACJ;AAEO,MAAMY,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBZ;IAChB,cAAc;QAACa;QAAkBC;QAAmBC;KAAmB;AAC3E"}

package/features/contentEntry/createEntry/CreateEntryRepository.d.ts

@@ -0,0 +1,13 @@
+import { CreateEntryRepository as RepositoryAbstraction, CreateEntryGateway } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../../../features/contentEntry/abstractions.js";
+import type { ICreateEntryGatewayParams } from "./abstractions.js";
+declare class CreateEntryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cacheProvider;
+    private gateway;
+    constructor(cacheProvider: ContentEntriesCacheProvider.Interface, gateway: CreateEntryGateway.Interface);
+    execute(params: ICreateEntryGatewayParams): Promise<import("@webiny/app-headless-cms-common/types/index.js").CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const CreateEntryRepository: typeof CreateEntryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateEntryRepository>;
+};
+export {};

package/features/contentEntry/createEntry/CreateEntryRepository.js

@@ -0,0 +1,26 @@
+import { CreateEntryGateway, CreateEntryRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../abstractions.js";
+class CreateEntryRepositoryImpl {
+    constructor(cacheProvider, gateway){
+        this.cacheProvider = cacheProvider;
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        const entry = await this.gateway.execute(params);
+        const cache = this.cacheProvider.get(params.model.modelId);
+        cache.addItems([
+            entry
+        ]);
+        return entry;
+    }
+}
+const CreateEntryRepository_CreateEntryRepository = CreateEntryRepository.createImplementation({
+    implementation: CreateEntryRepositoryImpl,
+    dependencies: [
+        ContentEntriesCacheProvider,
+        CreateEntryGateway
+    ]
+});
+export { CreateEntryRepository_CreateEntryRepository as CreateEntryRepository };
+
+//# sourceMappingURL=CreateEntryRepository.js.map

package/features/contentEntry/createEntry/CreateEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createEntry/CreateEntryRepository.js","sources":["../../../../src/features/contentEntry/createEntry/CreateEntryRepository.ts"],"sourcesContent":["import {\n    CreateEntryRepository as RepositoryAbstraction,\n    CreateEntryGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport type { ICreateEntryGatewayParams } from \"./abstractions.js\";\n\nclass CreateEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: CreateEntryGateway.Interface\n    ) {}\n\n    async execute(params: ICreateEntryGatewayParams) {\n        const entry = await this.gateway.execute(params);\n\n        const cache = this.cacheProvider.get(params.model.modelId);\n        cache.addItems([entry]);\n\n        return entry;\n    }\n}\n\nexport const CreateEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateEntryRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, CreateEntryGateway]\n});\n"],"names":["CreateEntryRepositoryImpl","cacheProvider","gateway","params","entry","cache","CreateEntryRepository","RepositoryAbstraction","ContentEntriesCacheProvider","CreateEntryGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAAqC,CAC/C;aAFUD,aAAa,GAAbA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAAiC,EAAE;QAC7C,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;QAEtB,OAAOA;IACX;AACJ;AAEO,MAAME,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBP;IAChB,cAAc;QAACQ;QAA6BC;KAAmB;AACnE"}

package/features/contentEntry/createEntry/CreateEntryUseCase.d.ts

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

package/features/contentEntry/createEntry/CreateEntryUseCase.js

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

package/features/contentEntry/createEntry/CreateEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createEntry/CreateEntryUseCase.js","sources":["../../../../src/features/contentEntry/createEntry/CreateEntryUseCase.ts"],"sourcesContent":["import { CreateEntryUseCase as UseCaseAbstraction, CreateEntryRepository } from \"./abstractions.js\";\nimport type { ICreateEntryGatewayParams } from \"./abstractions.js\";\n\nclass CreateEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: CreateEntryRepository.Interface) {}\n\n    async execute(params: ICreateEntryGatewayParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const CreateEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateEntryUseCaseImpl,\n    dependencies: [CreateEntryRepository]\n});\n"],"names":["CreateEntryUseCaseImpl","repository","params","CreateEntryUseCase","UseCaseAbstraction","CreateEntryRepository"],"mappings":";AAGA,MAAMA;IACF,YAAoBC,UAA2C,CAAE;aAA7CA,UAAU,GAAVA;IAA8C;IAElE,MAAM,QAAQC,MAAiC,EAAE;QAC7C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBJ;IAChB,cAAc;QAACK;KAAsB;AACzC"}

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

@@ -0,0 +1,29 @@
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface ICreateEntryGatewayParams {
+    model: CmsModel;
+    data: Record<string, unknown>;
+    options?: {
+        skipValidation?: boolean;
+    };
+}
+export interface ICreateEntryGateway {
+    execute(params: ICreateEntryGatewayParams): Promise<CmsContentEntry>;
+}
+export declare const CreateEntryGateway: import("@webiny/di").Abstraction<ICreateEntryGateway>;
+export declare namespace CreateEntryGateway {
+    type Interface = ICreateEntryGateway;
+}
+export interface ICreateEntryRepository {
+    execute(params: ICreateEntryGatewayParams): Promise<CmsContentEntry>;
+}
+export declare const CreateEntryRepository: import("@webiny/di").Abstraction<ICreateEntryRepository>;
+export declare namespace CreateEntryRepository {
+    type Interface = ICreateEntryRepository;
+}
+export interface ICreateEntryUseCase {
+    execute(params: ICreateEntryGatewayParams): Promise<CmsContentEntry>;
+}
+export declare const CreateEntryUseCase: import("@webiny/di").Abstraction<ICreateEntryUseCase>;
+export declare namespace CreateEntryUseCase {
+    type Interface = ICreateEntryUseCase;
+}

package/features/contentEntry/createEntry/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createEntry/abstractions.js","sources":["../../../../src/features/contentEntry/createEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\n// Gateway\n\nexport interface ICreateEntryGatewayParams {\n    model: CmsModel;\n    data: Record<string, unknown>;\n    options?: { skipValidation?: boolean };\n}\n\nexport interface ICreateEntryGateway {\n    execute(params: ICreateEntryGatewayParams): Promise<CmsContentEntry>;\n}\n\nexport const CreateEntryGateway = createAbstraction<ICreateEntryGateway>(\"CreateEntryGateway\");\n\nexport namespace CreateEntryGateway {\n    export type Interface = ICreateEntryGateway;\n}\n\n// Repository\n\nexport interface ICreateEntryRepository {\n    execute(params: ICreateEntryGatewayParams): Promise<CmsContentEntry>;\n}\n\nexport const CreateEntryRepository =\n    createAbstraction<ICreateEntryRepository>(\"CreateEntryRepository\");\n\nexport namespace CreateEntryRepository {\n    export type Interface = ICreateEntryRepository;\n}\n\n// UseCase\n\nexport interface ICreateEntryUseCase {\n    execute(params: ICreateEntryGatewayParams): Promise<CmsContentEntry>;\n}\n\nexport const CreateEntryUseCase = createAbstraction<ICreateEntryUseCase>(\"CreateEntryUseCase\");\n\nexport namespace CreateEntryUseCase {\n    export type Interface = ICreateEntryUseCase;\n}\n"],"names":["CreateEntryGateway","createAbstraction","CreateEntryRepository","CreateEntryUseCase"],"mappings":";AAeO,MAAMA,qBAAqBC,kBAAuC;AAYlE,MAAMC,wBACTD,kBAA0C;AAYvC,MAAME,qBAAqBF,kBAAuC"}

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

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

package/features/contentEntry/createEntry/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CreateEntryUseCase } from "./abstractions.js";
+import { CreateEntryUseCase as external_CreateEntryUseCase_js_CreateEntryUseCase } from "./CreateEntryUseCase.js";
+import { CreateEntryRepository } from "./CreateEntryRepository.js";
+import { CreateEntryGateway } from "./CreateEntryGateway.js";
+const CreateEntryFeature = createFeature({
+    name: "CmsContentEntry/CreateEntry",
+    register (container) {
+        container.register(external_CreateEntryUseCase_js_CreateEntryUseCase);
+        container.register(CreateEntryRepository).inSingletonScope();
+        container.register(CreateEntryGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(CreateEntryUseCase)
+        };
+    }
+});
+export { CreateEntryFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createEntry/feature.js","sources":["../../../../src/features/contentEntry/createEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CreateEntryUseCase as UseCase } from \"./abstractions.js\";\nimport { CreateEntryUseCase } from \"./CreateEntryUseCase.js\";\nimport { CreateEntryRepository } from \"./CreateEntryRepository.js\";\nimport { CreateEntryGateway } from \"./CreateEntryGateway.js\";\n\nexport const CreateEntryFeature = createFeature({\n    name: \"CmsContentEntry/CreateEntry\",\n    register(container) {\n        container.register(CreateEntryUseCase);\n        container.register(CreateEntryRepository).inSingletonScope();\n        container.register(CreateEntryGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["CreateEntryFeature","createFeature","container","CreateEntryUseCase","CreateEntryRepository","CreateEntryGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAC1DF,UAAU,QAAQ,CAACG,oBAAoB,gBAAgB;IAC3D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/contentEntry/createRevisionFrom/CreateRevisionFromGateway.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 { CreateRevisionFromGateway as GatewayAbstraction, type ICreateRevisionFromParams } from "./abstractions.js";
+declare class CreateRevisionFromGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    private fields;
+    constructor(client: CmsGraphQLClient.Interface, fields: EntryGraphQLFields.Interface);
+    execute({ model, revisionId, data, options }: ICreateRevisionFromParams): Promise<CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const CreateRevisionFromGateway: typeof CreateRevisionFromGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateRevisionFromGateway>;
+};
+export {};

package/features/contentEntry/createRevisionFrom/CreateRevisionFromGateway.js

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

package/features/contentEntry/createRevisionFrom/CreateRevisionFromGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createRevisionFrom/CreateRevisionFromGateway.js","sources":["../../../../src/features/contentEntry/createRevisionFrom/CreateRevisionFromGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsContentEntry, CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport { EntryGraphQLFields } from \"../abstractions.js\";\nimport {\n    CreateRevisionFromGateway as GatewayAbstraction,\n    type ICreateRevisionFromParams\n} from \"./abstractions.js\";\n\ninterface CreateRevisionFromResponse {\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 CmsCreate${model.singularApiName}From($revision: ID!, $data: ${model.singularApiName}Input, $options: CreateRevisionCmsEntryOptionsInput) {\n            content: create${model.singularApiName}From(revision: $revision, data: $data, options: $options) {\n                data {\n                    ${fields.getSystemFields(model)}\n                    ${fields.getValuesBlock(model)}\n                }\n                error { message code data }\n            }\n        }`;\n}\n\nclass CreateRevisionFromGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: CmsGraphQLClient.Interface,\n        private fields: EntryGraphQLFields.Interface\n    ) {}\n\n    async execute({ model, revisionId, data, options }: ICreateRevisionFromParams) {\n        const response = await this.client.execute<CreateRevisionFromResponse>({\n            query: createMutation(model, this.fields),\n            variables: { revision: revisionId, data, options }\n        });\n\n        const { data: entry, error } = response.content;\n\n        if (!entry) {\n            throw new Error(error?.message || \"Could not create revision\");\n        }\n\n        return entry;\n    }\n}\n\nexport const CreateRevisionFromGateway = GatewayAbstraction.createImplementation({\n    implementation: CreateRevisionFromGatewayImpl,\n    dependencies: [CmsGraphQLClient, EntryGraphQLFields]\n});\n"],"names":["createMutation","model","fields","CreateRevisionFromGatewayImpl","client","revisionId","data","options","response","entry","error","Error","CreateRevisionFromGateway","GatewayAbstraction","CmsGraphQLClient","EntryGraphQLFields"],"mappings":";;;AAeA,SAASA,eAAeC,KAAe,EAAEC,MAAoC;IACzE,OAAqB,CAAC;0BACA,EAAED,MAAM,eAAe,CAAC,4BAA4B,EAAEA,MAAM,eAAe,CAAC;2BAC3E,EAAEA,MAAM,eAAe,CAAC;;oBAE/B,EAAEC,OAAO,eAAe,CAACD,OAAO;oBAChC,EAAEC,OAAO,cAAc,CAACD,OAAO;;;;SAI1C,CAAC;AACV;AAEA,MAAME;IACF,YACYC,MAAkC,EAClCF,MAAoC,CAC9C;aAFUE,MAAM,GAANA;aACAF,MAAM,GAANA;IACT;IAEH,MAAM,QAAQ,EAAED,KAAK,EAAEI,UAAU,EAAEC,IAAI,EAAEC,OAAO,EAA6B,EAAE;QAC3E,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA6B;YACnE,OAAOR,eAAeC,OAAO,IAAI,CAAC,MAAM;YACxC,WAAW;gBAAE,UAAUI;gBAAYC;gBAAMC;YAAQ;QACrD;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,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBV;IAChB,cAAc;QAACW;QAAkBC;KAAmB;AACxD"}

package/features/contentEntry/createRevisionFrom/CreateRevisionFromRepository.d.ts

@@ -0,0 +1,13 @@
+import { CreateRevisionFromRepository as RepositoryAbstraction, CreateRevisionFromGateway } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../../../features/contentEntry/abstractions.js";
+import type { ICreateRevisionFromParams } from "./abstractions.js";
+declare class CreateRevisionFromRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cacheProvider;
+    private gateway;
+    constructor(cacheProvider: ContentEntriesCacheProvider.Interface, gateway: CreateRevisionFromGateway.Interface);
+    execute(params: ICreateRevisionFromParams): Promise<import("@webiny/app-headless-cms-common/types/index.js").CmsContentEntry<import("@webiny/app/types.js").GenericRecord>>;
+}
+export declare const CreateRevisionFromRepository: typeof CreateRevisionFromRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateRevisionFromRepository>;
+};
+export {};

package/features/contentEntry/createRevisionFrom/CreateRevisionFromRepository.js

@@ -0,0 +1,26 @@
+import { CreateRevisionFromGateway, CreateRevisionFromRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../abstractions.js";
+class CreateRevisionFromRepositoryImpl {
+    constructor(cacheProvider, gateway){
+        this.cacheProvider = cacheProvider;
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        const entry = await this.gateway.execute(params);
+        const cache = this.cacheProvider.get(params.model.modelId);
+        cache.addItems([
+            entry
+        ]);
+        return entry;
+    }
+}
+const CreateRevisionFromRepository_CreateRevisionFromRepository = CreateRevisionFromRepository.createImplementation({
+    implementation: CreateRevisionFromRepositoryImpl,
+    dependencies: [
+        ContentEntriesCacheProvider,
+        CreateRevisionFromGateway
+    ]
+});
+export { CreateRevisionFromRepository_CreateRevisionFromRepository as CreateRevisionFromRepository };
+
+//# sourceMappingURL=CreateRevisionFromRepository.js.map

package/features/contentEntry/createRevisionFrom/CreateRevisionFromRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createRevisionFrom/CreateRevisionFromRepository.js","sources":["../../../../src/features/contentEntry/createRevisionFrom/CreateRevisionFromRepository.ts"],"sourcesContent":["import {\n    CreateRevisionFromRepository as RepositoryAbstraction,\n    CreateRevisionFromGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport type { ICreateRevisionFromParams } from \"./abstractions.js\";\n\nclass CreateRevisionFromRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: CreateRevisionFromGateway.Interface\n    ) {}\n\n    async execute(params: ICreateRevisionFromParams) {\n        const entry = await this.gateway.execute(params);\n\n        const cache = this.cacheProvider.get(params.model.modelId);\n        cache.addItems([entry]);\n\n        return entry;\n    }\n}\n\nexport const CreateRevisionFromRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateRevisionFromRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, CreateRevisionFromGateway]\n});\n"],"names":["CreateRevisionFromRepositoryImpl","cacheProvider","gateway","params","entry","cache","CreateRevisionFromRepository","RepositoryAbstraction","ContentEntriesCacheProvider","CreateRevisionFromGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAA4C,CACtD;aAFUD,aAAa,GAAbA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAAiC,EAAE;QAC7C,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;QAEtB,OAAOA;IACX;AACJ;AAEO,MAAME,4DAA+BC,6BAAAA,oBAA0C,CAAC;IACnF,gBAAgBP;IAChB,cAAc;QAACQ;QAA6BC;KAA0B;AAC1E"}

package/features/contentEntry/createRevisionFrom/CreateRevisionFromUseCase.d.ts

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

package/features/contentEntry/createRevisionFrom/CreateRevisionFromUseCase.js

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

package/features/contentEntry/createRevisionFrom/CreateRevisionFromUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createRevisionFrom/CreateRevisionFromUseCase.js","sources":["../../../../src/features/contentEntry/createRevisionFrom/CreateRevisionFromUseCase.ts"],"sourcesContent":["import {\n    CreateRevisionFromUseCase as UseCaseAbstraction,\n    CreateRevisionFromRepository\n} from \"./abstractions.js\";\nimport type { ICreateRevisionFromParams } from \"./abstractions.js\";\n\nclass CreateRevisionFromUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: CreateRevisionFromRepository.Interface) {}\n\n    async execute(params: ICreateRevisionFromParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const CreateRevisionFromUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateRevisionFromUseCaseImpl,\n    dependencies: [CreateRevisionFromRepository]\n});\n"],"names":["CreateRevisionFromUseCaseImpl","repository","params","CreateRevisionFromUseCase","UseCaseAbstraction","CreateRevisionFromRepository"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,UAAkD,CAAE;aAApDA,UAAU,GAAVA;IAAqD;IAEzE,MAAM,QAAQC,MAAiC,EAAE;QAC7C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAAuC,CAAC;IAC7E,gBAAgBJ;IAChB,cAAc;QAACK;KAA6B;AAChD"}

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

@@ -0,0 +1,30 @@
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface ICreateRevisionFromParams {
+    model: CmsModel;
+    revisionId: string;
+    data?: Record<string, unknown>;
+    options?: {
+        skipValidation?: boolean;
+    };
+}
+export interface ICreateRevisionFromGateway {
+    execute(params: ICreateRevisionFromParams): Promise<CmsContentEntry>;
+}
+export declare const CreateRevisionFromGateway: import("@webiny/di").Abstraction<ICreateRevisionFromGateway>;
+export declare namespace CreateRevisionFromGateway {
+    type Interface = ICreateRevisionFromGateway;
+}
+export interface ICreateRevisionFromRepository {
+    execute(params: ICreateRevisionFromParams): Promise<CmsContentEntry>;
+}
+export declare const CreateRevisionFromRepository: import("@webiny/di").Abstraction<ICreateRevisionFromRepository>;
+export declare namespace CreateRevisionFromRepository {
+    type Interface = ICreateRevisionFromRepository;
+}
+export interface ICreateRevisionFromUseCase {
+    execute(params: ICreateRevisionFromParams): Promise<CmsContentEntry>;
+}
+export declare const CreateRevisionFromUseCase: import("@webiny/di").Abstraction<ICreateRevisionFromUseCase>;
+export declare namespace CreateRevisionFromUseCase {
+    type Interface = ICreateRevisionFromUseCase;
+}

package/features/contentEntry/createRevisionFrom/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createRevisionFrom/abstractions.js","sources":["../../../../src/features/contentEntry/createRevisionFrom/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\nexport interface ICreateRevisionFromParams {\n    model: CmsModel;\n    revisionId: string;\n    data?: Record<string, unknown>;\n    options?: { skipValidation?: boolean };\n}\n\nexport interface ICreateRevisionFromGateway {\n    execute(params: ICreateRevisionFromParams): Promise<CmsContentEntry>;\n}\n\nexport const CreateRevisionFromGateway = createAbstraction<ICreateRevisionFromGateway>(\n    \"CreateRevisionFromGateway\"\n);\n\nexport namespace CreateRevisionFromGateway {\n    export type Interface = ICreateRevisionFromGateway;\n}\n\nexport interface ICreateRevisionFromRepository {\n    execute(params: ICreateRevisionFromParams): Promise<CmsContentEntry>;\n}\n\nexport const CreateRevisionFromRepository = createAbstraction<ICreateRevisionFromRepository>(\n    \"CreateRevisionFromRepository\"\n);\n\nexport namespace CreateRevisionFromRepository {\n    export type Interface = ICreateRevisionFromRepository;\n}\n\nexport interface ICreateRevisionFromUseCase {\n    execute(params: ICreateRevisionFromParams): Promise<CmsContentEntry>;\n}\n\nexport const CreateRevisionFromUseCase = createAbstraction<ICreateRevisionFromUseCase>(\n    \"CreateRevisionFromUseCase\"\n);\n\nexport namespace CreateRevisionFromUseCase {\n    export type Interface = ICreateRevisionFromUseCase;\n}\n"],"names":["CreateRevisionFromGateway","createAbstraction","CreateRevisionFromRepository","CreateRevisionFromUseCase"],"mappings":";AAcO,MAAMA,4BAA4BC,kBACrC;AAWG,MAAMC,+BAA+BD,kBACxC;AAWG,MAAME,4BAA4BF,kBACrC"}

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

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

package/features/contentEntry/createRevisionFrom/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CreateRevisionFromUseCase } from "./abstractions.js";
+import { CreateRevisionFromUseCase as external_CreateRevisionFromUseCase_js_CreateRevisionFromUseCase } from "./CreateRevisionFromUseCase.js";
+import { CreateRevisionFromRepository } from "./CreateRevisionFromRepository.js";
+import { CreateRevisionFromGateway } from "./CreateRevisionFromGateway.js";
+const CreateRevisionFromFeature = createFeature({
+    name: "CmsContentEntry/CreateRevisionFrom",
+    register (container) {
+        container.register(external_CreateRevisionFromUseCase_js_CreateRevisionFromUseCase);
+        container.register(CreateRevisionFromRepository).inSingletonScope();
+        container.register(CreateRevisionFromGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(CreateRevisionFromUseCase)
+        };
+    }
+});
+export { CreateRevisionFromFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/createRevisionFrom/feature.js","sources":["../../../../src/features/contentEntry/createRevisionFrom/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CreateRevisionFromUseCase as UseCase } from \"./abstractions.js\";\nimport { CreateRevisionFromUseCase } from \"./CreateRevisionFromUseCase.js\";\nimport { CreateRevisionFromRepository } from \"./CreateRevisionFromRepository.js\";\nimport { CreateRevisionFromGateway } from \"./CreateRevisionFromGateway.js\";\n\nexport const CreateRevisionFromFeature = createFeature({\n    name: \"CmsContentEntry/CreateRevisionFrom\",\n    register(container) {\n        container.register(CreateRevisionFromUseCase);\n        container.register(CreateRevisionFromRepository).inSingletonScope();\n        container.register(CreateRevisionFromGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["CreateRevisionFromFeature","createFeature","container","CreateRevisionFromUseCase","CreateRevisionFromRepository","CreateRevisionFromGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,8BAA8B,gBAAgB;QACjEF,UAAU,QAAQ,CAACG,2BAA2B,gBAAgB;IAClE;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/contentEntry/deleteEntry/DeleteEntryGateway.d.ts

@@ -0,0 +1,11 @@
+import { CmsGraphQLClient } from "../../../features/graphQLClient/abstractions.js";
+import { DeleteEntryGateway as GatewayAbstraction, type IDeleteEntryParams } from "./abstractions.js";
+declare class DeleteEntryGatewayImpl implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: CmsGraphQLClient.Interface);
+    execute({ model, id }: IDeleteEntryParams): Promise<boolean>;
+}
+export declare const DeleteEntryGateway: typeof DeleteEntryGatewayImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteEntryGateway>;
+};
+export {};

package/features/contentEntry/deleteEntry/DeleteEntryGateway.js

@@ -0,0 +1,38 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { DeleteEntryGateway } from "./abstractions.js";
+function createMutation(model) {
+    return `
+        mutation CmsEntriesDelete${model.singularApiName}($revision: ID!, $permanently: Boolean) {
+            content: delete${model.singularApiName}(revision: $revision, options: {permanently: $permanently}) {
+                data
+                error { message code data }
+            }
+        }
+    `;
+}
+class DeleteEntryGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute({ model, id }) {
+        const response = await this.client.execute({
+            query: createMutation(model),
+            variables: {
+                revision: id,
+                permanently: false
+            }
+        });
+        const { error } = response.content;
+        if (error) throw new Error(error.message || "Could not delete entry");
+        return true;
+    }
+}
+const DeleteEntryGateway_DeleteEntryGateway = DeleteEntryGateway.createImplementation({
+    implementation: DeleteEntryGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { DeleteEntryGateway_DeleteEntryGateway as DeleteEntryGateway };
+
+//# sourceMappingURL=DeleteEntryGateway.js.map

package/features/contentEntry/deleteEntry/DeleteEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/deleteEntry/DeleteEntryGateway.js","sources":["../../../../src/features/contentEntry/deleteEntry/DeleteEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport {\n    DeleteEntryGateway as GatewayAbstraction,\n    type IDeleteEntryParams\n} from \"./abstractions.js\";\n\ninterface DeleteEntryResponse {\n    content: {\n        data: boolean | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\nfunction createMutation(model: CmsModel) {\n    return /* GraphQL */ `\n        mutation CmsEntriesDelete${model.singularApiName}($revision: ID!, $permanently: Boolean) {\n            content: delete${model.singularApiName}(revision: $revision, options: {permanently: $permanently}) {\n                data\n                error { message code data }\n            }\n        }\n    `;\n}\n\nclass DeleteEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute({ model, id }: IDeleteEntryParams) {\n        const response = await this.client.execute<DeleteEntryResponse>({\n            query: createMutation(model),\n            variables: { revision: id, permanently: false }\n        });\n\n        const { error } = response.content;\n\n        if (error) {\n            throw new Error(error.message || \"Could not delete entry\");\n        }\n\n        return true;\n    }\n}\n\nexport const DeleteEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: DeleteEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["createMutation","model","DeleteEntryGatewayImpl","client","id","response","error","Error","DeleteEntryGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;AAcA,SAASA,eAAeC,KAAe;IACnC,OAAqB,CAAC;iCACO,EAAEA,MAAM,eAAe,CAAC;2BAC9B,EAAEA,MAAM,eAAe,CAAC;;;;;IAK/C,CAAC;AACL;AAEA,MAAMC;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QAAQ,EAAEF,KAAK,EAAEG,EAAE,EAAsB,EAAE;QAC7C,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAsB;YAC5D,OAAOL,eAAeC;YACtB,WAAW;gBAAE,UAAUG;gBAAI,aAAa;YAAM;QAClD;QAEA,MAAM,EAAEE,KAAK,EAAE,GAAGD,SAAS,OAAO;QAElC,IAAIC,OACA,MAAM,IAAIC,MAAMD,MAAM,OAAO,IAAI;QAGrC,OAAO;IACX;AACJ;AAEO,MAAME,wCAAqBC,mBAAAA,oBAAuC,CAAC;IACtE,gBAAgBP;IAChB,cAAc;QAACQ;KAAiB;AACpC"}

package/features/contentEntry/deleteEntry/DeleteEntryRepository.d.ts

@@ -0,0 +1,13 @@
+import { DeleteEntryRepository as RepositoryAbstraction, DeleteEntryGateway } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../../../features/contentEntry/abstractions.js";
+import type { IDeleteEntryParams } from "./abstractions.js";
+declare class DeleteEntryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private cacheProvider;
+    private gateway;
+    constructor(cacheProvider: ContentEntriesCacheProvider.Interface, gateway: DeleteEntryGateway.Interface);
+    execute(params: IDeleteEntryParams): Promise<boolean>;
+}
+export declare const DeleteEntryRepository: typeof DeleteEntryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteEntryRepository>;
+};
+export {};

package/features/contentEntry/deleteEntry/DeleteEntryRepository.js

@@ -0,0 +1,24 @@
+import { DeleteEntryGateway, DeleteEntryRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../abstractions.js";
+class DeleteEntryRepositoryImpl {
+    constructor(cacheProvider, gateway){
+        this.cacheProvider = cacheProvider;
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        const result = await this.gateway.execute(params);
+        const cache = this.cacheProvider.get(params.model.modelId);
+        cache.removeItems((item)=>item.id === params.id || item.entryId === params.id);
+        return result;
+    }
+}
+const DeleteEntryRepository_DeleteEntryRepository = DeleteEntryRepository.createImplementation({
+    implementation: DeleteEntryRepositoryImpl,
+    dependencies: [
+        ContentEntriesCacheProvider,
+        DeleteEntryGateway
+    ]
+});
+export { DeleteEntryRepository_DeleteEntryRepository as DeleteEntryRepository };
+
+//# sourceMappingURL=DeleteEntryRepository.js.map

package/features/contentEntry/deleteEntry/DeleteEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/deleteEntry/DeleteEntryRepository.js","sources":["../../../../src/features/contentEntry/deleteEntry/DeleteEntryRepository.ts"],"sourcesContent":["import {\n    DeleteEntryRepository as RepositoryAbstraction,\n    DeleteEntryGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport type { IDeleteEntryParams } from \"./abstractions.js\";\n\nclass DeleteEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: DeleteEntryGateway.Interface\n    ) {}\n\n    async execute(params: IDeleteEntryParams) {\n        const result = await this.gateway.execute(params);\n\n        const cache = this.cacheProvider.get(params.model.modelId);\n        cache.removeItems(item => item.id === params.id || item.entryId === params.id);\n\n        return result;\n    }\n}\n\nexport const DeleteEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: DeleteEntryRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, DeleteEntryGateway]\n});\n"],"names":["DeleteEntryRepositoryImpl","cacheProvider","gateway","params","result","cache","item","DeleteEntryRepository","RepositoryAbstraction","ContentEntriesCacheProvider","DeleteEntryGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAAqC,CAC/C;aAFUD,aAAa,GAAbA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAA0B,EAAE;QACtC,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QAE1C,MAAME,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAACF,OAAO,KAAK,CAAC,OAAO;QACzDE,MAAM,WAAW,CAACC,CAAAA,OAAQA,KAAK,EAAE,KAAKH,OAAO,EAAE,IAAIG,KAAK,OAAO,KAAKH,OAAO,EAAE;QAE7E,OAAOC;IACX;AACJ;AAEO,MAAMG,8CAAwBC,sBAAAA,oBAA0C,CAAC;IAC5E,gBAAgBR;IAChB,cAAc;QAACS;QAA6BC;KAAmB;AACnE"}

package/features/contentEntry/deleteEntry/DeleteEntryUseCase.d.ts

@@ -0,0 +1,11 @@
+import { DeleteEntryUseCase as UseCaseAbstraction, DeleteEntryRepository } from "./abstractions.js";
+import type { IDeleteEntryParams } from "./abstractions.js";
+declare class DeleteEntryUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: DeleteEntryRepository.Interface);
+    execute(params: IDeleteEntryParams): Promise<boolean>;
+}
+export declare const DeleteEntryUseCase: typeof DeleteEntryUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteEntryUseCase>;
+};
+export {};