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

package/features/contentEntry/moveEntry/MoveEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/moveEntry/MoveEntryGateway.js","sources":["../../../../src/features/contentEntry/moveEntry/MoveEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport { MoveEntryGateway as GatewayAbstraction, type IMoveEntryParams } from \"./abstractions.js\";\n\nfunction createMoveMutation(model: CmsModel) {\n    return /* GraphQL */ `\n        mutation CmsMove${model.singularApiName}($revision: ID!, $folderId: ID!) {\n            content: move${model.singularApiName}(revision: $revision, folderId: $folderId) {\n                data\n                error {\n                    message\n                    code\n                    data\n                }\n            }\n        }\n    `;\n}\n\ninterface MoveEntryResponse {\n    content: {\n        data: boolean | null;\n        error: CmsErrorResponse | null;\n    };\n}\n\nclass MoveEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute({ model, id, folderId }: IMoveEntryParams) {\n        const mutation = createMoveMutation(model);\n\n        const response = await this.client.execute<MoveEntryResponse>({\n            query: mutation,\n            variables: { revision: id, folderId }\n        });\n\n        const { error } = response.content;\n\n        if (error) {\n            throw new Error(error.message || \"Could not move entry\");\n        }\n\n        return true;\n    }\n}\n\nexport const MoveEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: MoveEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["createMoveMutation","model","MoveEntryGatewayImpl","client","id","folderId","mutation","response","error","Error","MoveEntryGateway","GatewayAbstraction","CmsGraphQLClient"],"mappings":";;AAIA,SAASA,mBAAmBC,KAAe;IACvC,OAAqB,CAAC;wBACF,EAAEA,MAAM,eAAe,CAAC;yBACvB,EAAEA,MAAM,eAAe,CAAC;;;;;;;;;IAS7C,CAAC;AACL;AASA,MAAMC;IACF,YAAoBC,MAAkC,CAAE;aAApCA,MAAM,GAANA;IAAqC;IAEzD,MAAM,QAAQ,EAAEF,KAAK,EAAEG,EAAE,EAAEC,QAAQ,EAAoB,EAAE;QACrD,MAAMC,WAAWN,mBAAmBC;QAEpC,MAAMM,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAoB;YAC1D,OAAOD;YACP,WAAW;gBAAE,UAAUF;gBAAIC;YAAS;QACxC;QAEA,MAAM,EAAEG,KAAK,EAAE,GAAGD,SAAS,OAAO;QAElC,IAAIC,OACA,MAAM,IAAIC,MAAMD,MAAM,OAAO,IAAI;QAGrC,OAAO;IACX;AACJ;AAEO,MAAME,oCAAmBC,iBAAAA,oBAAuC,CAAC;IACpE,gBAAgBT;IAChB,cAAc;QAACU;KAAiB;AACpC"}

package/features/contentEntry/moveEntry/MoveEntryRepository.d.ts

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

package/features/contentEntry/moveEntry/MoveEntryRepository.js

@@ -0,0 +1,24 @@
+import { MoveEntryGateway, MoveEntryRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../abstractions.js";
+class MoveEntryRepositoryImpl {
+    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);
+        return result;
+    }
+}
+const MoveEntryRepository_MoveEntryRepository = MoveEntryRepository.createImplementation({
+    implementation: MoveEntryRepositoryImpl,
+    dependencies: [
+        ContentEntriesCacheProvider,
+        MoveEntryGateway
+    ]
+});
+export { MoveEntryRepository_MoveEntryRepository as MoveEntryRepository };
+
+//# sourceMappingURL=MoveEntryRepository.js.map

package/features/contentEntry/moveEntry/MoveEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/moveEntry/MoveEntryRepository.js","sources":["../../../../src/features/contentEntry/moveEntry/MoveEntryRepository.ts"],"sourcesContent":["import { MoveEntryRepository as RepositoryAbstraction, MoveEntryGateway } from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport type { IMoveEntryParams } from \"./abstractions.js\";\n\nclass MoveEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: MoveEntryGateway.Interface\n    ) {}\n\n    async execute(params: IMoveEntryParams) {\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);\n\n        return result;\n    }\n}\n\nexport const MoveEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: MoveEntryRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, MoveEntryGateway]\n});\n"],"names":["MoveEntryRepositoryImpl","cacheProvider","gateway","params","result","cache","item","MoveEntryRepository","RepositoryAbstraction","ContentEntriesCacheProvider","MoveEntryGateway"],"mappings":";;AAIA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAAmC,CAC7C;aAFUD,aAAa,GAAbA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAAwB,EAAE;QACpC,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;QAE/C,OAAOC;IACX;AACJ;AAEO,MAAMG,0CAAsBC,oBAAAA,oBAA0C,CAAC;IAC1E,gBAAgBR;IAChB,cAAc;QAACS;QAA6BC;KAAiB;AACjE"}

package/features/contentEntry/moveEntry/MoveEntryUseCase.d.ts

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

package/features/contentEntry/moveEntry/MoveEntryUseCase.js

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

package/features/contentEntry/moveEntry/MoveEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/moveEntry/MoveEntryUseCase.js","sources":["../../../../src/features/contentEntry/moveEntry/MoveEntryUseCase.ts"],"sourcesContent":["import { MoveEntryUseCase as UseCaseAbstraction, MoveEntryRepository } from \"./abstractions.js\";\nimport type { IMoveEntryParams } from \"./abstractions.js\";\n\nclass MoveEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: MoveEntryRepository.Interface) {}\n\n    async execute(params: IMoveEntryParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const MoveEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: MoveEntryUseCaseImpl,\n    dependencies: [MoveEntryRepository]\n});\n"],"names":["MoveEntryUseCaseImpl","repository","params","MoveEntryUseCase","UseCaseAbstraction","MoveEntryRepository"],"mappings":";AAGA,MAAMA;IACF,YAAoBC,UAAyC,CAAE;aAA3CA,UAAU,GAAVA;IAA4C;IAEhE,MAAM,QAAQC,MAAwB,EAAE;QACpC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,oCAAmBC,iBAAAA,oBAAuC,CAAC;IACpE,gBAAgBJ;IAChB,cAAc;QAACK;KAAoB;AACvC"}

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

@@ -0,0 +1,27 @@
+import type { CmsModel } from "../../../types.js";
+export interface IMoveEntryParams {
+    model: CmsModel;
+    id: string;
+    folderId: string;
+}
+export interface IMoveEntryGateway {
+    execute(params: IMoveEntryParams): Promise<boolean>;
+}
+export declare const MoveEntryGateway: import("@webiny/di").Abstraction<IMoveEntryGateway>;
+export declare namespace MoveEntryGateway {
+    type Interface = IMoveEntryGateway;
+}
+export interface IMoveEntryRepository {
+    execute(params: IMoveEntryParams): Promise<boolean>;
+}
+export declare const MoveEntryRepository: import("@webiny/di").Abstraction<IMoveEntryRepository>;
+export declare namespace MoveEntryRepository {
+    type Interface = IMoveEntryRepository;
+}
+export interface IMoveEntryUseCase {
+    execute(params: IMoveEntryParams): Promise<boolean>;
+}
+export declare const MoveEntryUseCase: import("@webiny/di").Abstraction<IMoveEntryUseCase>;
+export declare namespace MoveEntryUseCase {
+    type Interface = IMoveEntryUseCase;
+}

package/features/contentEntry/moveEntry/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/moveEntry/abstractions.js","sources":["../../../../src/features/contentEntry/moveEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsModel } from \"~/types.js\";\n\nexport interface IMoveEntryParams {\n    model: CmsModel;\n    id: string;\n    folderId: string;\n}\n\nexport interface IMoveEntryGateway {\n    execute(params: IMoveEntryParams): Promise<boolean>;\n}\n\nexport const MoveEntryGateway = createAbstraction<IMoveEntryGateway>(\"MoveEntryGateway\");\n\nexport namespace MoveEntryGateway {\n    export type Interface = IMoveEntryGateway;\n}\n\nexport interface IMoveEntryRepository {\n    execute(params: IMoveEntryParams): Promise<boolean>;\n}\n\nexport const MoveEntryRepository = createAbstraction<IMoveEntryRepository>(\"MoveEntryRepository\");\n\nexport namespace MoveEntryRepository {\n    export type Interface = IMoveEntryRepository;\n}\n\nexport interface IMoveEntryUseCase {\n    execute(params: IMoveEntryParams): Promise<boolean>;\n}\n\nexport const MoveEntryUseCase = createAbstraction<IMoveEntryUseCase>(\"MoveEntryUseCase\");\n\nexport namespace MoveEntryUseCase {\n    export type Interface = IMoveEntryUseCase;\n}\n"],"names":["MoveEntryGateway","createAbstraction","MoveEntryRepository","MoveEntryUseCase"],"mappings":";AAaO,MAAMA,mBAAmBC,kBAAqC;AAU9D,MAAMC,sBAAsBD,kBAAwC;AAUpE,MAAME,mBAAmBF,kBAAqC"}

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

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

package/features/contentEntry/moveEntry/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { MoveEntryUseCase } from "./abstractions.js";
+import { MoveEntryUseCase as external_MoveEntryUseCase_js_MoveEntryUseCase } from "./MoveEntryUseCase.js";
+import { MoveEntryRepository } from "./MoveEntryRepository.js";
+import { MoveEntryGateway } from "./MoveEntryGateway.js";
+const MoveEntryFeature = createFeature({
+    name: "CmsContentEntry/MoveEntry",
+    register (container) {
+        container.register(external_MoveEntryUseCase_js_MoveEntryUseCase);
+        container.register(MoveEntryRepository).inSingletonScope();
+        container.register(MoveEntryGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(MoveEntryUseCase)
+        };
+    }
+});
+export { MoveEntryFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/moveEntry/feature.js","sources":["../../../../src/features/contentEntry/moveEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { MoveEntryUseCase as UseCase } from \"./abstractions.js\";\nimport { MoveEntryUseCase } from \"./MoveEntryUseCase.js\";\nimport { MoveEntryRepository } from \"./MoveEntryRepository.js\";\nimport { MoveEntryGateway } from \"./MoveEntryGateway.js\";\n\nexport const MoveEntryFeature = createFeature({\n    name: \"CmsContentEntry/MoveEntry\",\n    register(container) {\n        container.register(MoveEntryUseCase);\n        container.register(MoveEntryRepository).inSingletonScope();\n        container.register(MoveEntryGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["MoveEntryFeature","createFeature","container","MoveEntryUseCase","MoveEntryRepository","MoveEntryGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,qBAAqB,gBAAgB;QACxDF,UAAU,QAAQ,CAACG,kBAAkB,gBAAgB;IACzD;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryGateway.d.ts

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

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryGateway.js

@@ -0,0 +1,38 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { PermanentlyDeleteEntryGateway } 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 PermanentlyDeleteEntryGatewayImpl {
+    constructor(client){
+        this.client = client;
+    }
+    async execute({ model, id }) {
+        const response = await this.client.execute({
+            query: createMutation(model),
+            variables: {
+                revision: id,
+                permanently: true
+            }
+        });
+        const { data, error } = response.content;
+        if (!data) throw new Error(error?.message || "Could not permanently delete the entry.");
+        return true;
+    }
+}
+const PermanentlyDeleteEntryGateway_PermanentlyDeleteEntryGateway = PermanentlyDeleteEntryGateway.createImplementation({
+    implementation: PermanentlyDeleteEntryGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient
+    ]
+});
+export { PermanentlyDeleteEntryGateway_PermanentlyDeleteEntryGateway as PermanentlyDeleteEntryGateway };
+
+//# sourceMappingURL=PermanentlyDeleteEntryGateway.js.map

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryGateway.js","sources":["../../../../src/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport {\n    PermanentlyDeleteEntryGateway as GatewayAbstraction,\n    type IPermanentlyDeleteEntryParams\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 PermanentlyDeleteEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private client: CmsGraphQLClient.Interface) {}\n\n    async execute({ model, id }: IPermanentlyDeleteEntryParams): Promise<boolean> {\n        const response = await this.client.execute<DeleteEntryResponse>({\n            query: createMutation(model),\n            variables: { revision: id, permanently: true }\n        });\n\n        const { data, error } = response.content;\n\n        if (!data) {\n            throw new Error(error?.message || \"Could not permanently delete the entry.\");\n        }\n\n        return true;\n    }\n}\n\nexport const PermanentlyDeleteEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: PermanentlyDeleteEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient]\n});\n"],"names":["createMutation","model","PermanentlyDeleteEntryGatewayImpl","client","id","response","data","error","Error","PermanentlyDeleteEntryGateway","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,EAAiC,EAAoB;QAC1E,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAsB;YAC5D,OAAOL,eAAeC;YACtB,WAAW;gBAAE,UAAUG;gBAAI,aAAa;YAAK;QACjD;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAExC,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAO;IACX;AACJ;AAEO,MAAME,8DAAgCC,8BAAAA,oBAAuC,CAAC;IACjF,gBAAgBR;IAChB,cAAc;QAACS;KAAiB;AACpC"}

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryRepository.d.ts

@@ -0,0 +1,11 @@
+import { PermanentlyDeleteEntryRepository as RepositoryAbstraction, PermanentlyDeleteEntryGateway } from "./abstractions.js";
+import type { IPermanentlyDeleteEntryParams } from "./abstractions.js";
+declare class PermanentlyDeleteEntryRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    constructor(gateway: PermanentlyDeleteEntryGateway.Interface);
+    execute(params: IPermanentlyDeleteEntryParams): Promise<boolean>;
+}
+export declare const PermanentlyDeleteEntryRepository: typeof PermanentlyDeleteEntryRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IPermanentlyDeleteEntryRepository>;
+};
+export {};

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryRepository.js

@@ -0,0 +1,18 @@
+import { PermanentlyDeleteEntryGateway, PermanentlyDeleteEntryRepository } from "./abstractions.js";
+class PermanentlyDeleteEntryRepositoryImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(params) {
+        return this.gateway.execute(params);
+    }
+}
+const PermanentlyDeleteEntryRepository_PermanentlyDeleteEntryRepository = PermanentlyDeleteEntryRepository.createImplementation({
+    implementation: PermanentlyDeleteEntryRepositoryImpl,
+    dependencies: [
+        PermanentlyDeleteEntryGateway
+    ]
+});
+export { PermanentlyDeleteEntryRepository_PermanentlyDeleteEntryRepository as PermanentlyDeleteEntryRepository };
+
+//# sourceMappingURL=PermanentlyDeleteEntryRepository.js.map

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryRepository.js","sources":["../../../../src/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryRepository.ts"],"sourcesContent":["import {\n    PermanentlyDeleteEntryRepository as RepositoryAbstraction,\n    PermanentlyDeleteEntryGateway\n} from \"./abstractions.js\";\nimport type { IPermanentlyDeleteEntryParams } from \"./abstractions.js\";\n\nclass PermanentlyDeleteEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(private gateway: PermanentlyDeleteEntryGateway.Interface) {}\n\n    async execute(params: IPermanentlyDeleteEntryParams) {\n        return this.gateway.execute(params);\n    }\n}\n\nexport const PermanentlyDeleteEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: PermanentlyDeleteEntryRepositoryImpl,\n    dependencies: [PermanentlyDeleteEntryGateway]\n});\n"],"names":["PermanentlyDeleteEntryRepositoryImpl","gateway","params","PermanentlyDeleteEntryRepository","RepositoryAbstraction","PermanentlyDeleteEntryGateway"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,OAAgD,CAAE;aAAlDA,OAAO,GAAPA;IAAmD;IAEvE,MAAM,QAAQC,MAAqC,EAAE;QACjD,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAACA;IAChC;AACJ;AAEO,MAAMC,oEAAmCC,iCAAAA,oBAA0C,CAAC;IACvF,gBAAgBJ;IAChB,cAAc;QAACK;KAA8B;AACjD"}

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryUseCase.d.ts

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

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryUseCase.js

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

package/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryUseCase.js","sources":["../../../../src/features/contentEntry/permanentlyDeleteEntry/PermanentlyDeleteEntryUseCase.ts"],"sourcesContent":["import {\n    PermanentlyDeleteEntryUseCase as UseCaseAbstraction,\n    PermanentlyDeleteEntryRepository\n} from \"./abstractions.js\";\nimport type { IPermanentlyDeleteEntryParams } from \"./abstractions.js\";\n\nclass PermanentlyDeleteEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: PermanentlyDeleteEntryRepository.Interface) {}\n\n    async execute(params: IPermanentlyDeleteEntryParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const PermanentlyDeleteEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: PermanentlyDeleteEntryUseCaseImpl,\n    dependencies: [PermanentlyDeleteEntryRepository]\n});\n"],"names":["PermanentlyDeleteEntryUseCaseImpl","repository","params","PermanentlyDeleteEntryUseCase","UseCaseAbstraction","PermanentlyDeleteEntryRepository"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,UAAsD,CAAE;aAAxDA,UAAU,GAAVA;IAAyD;IAE7E,MAAM,QAAQC,MAAqC,EAAE;QACjD,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,8DAAgCC,8BAAAA,oBAAuC,CAAC;IACjF,gBAAgBJ;IAChB,cAAc;QAACK;KAAiC;AACpD"}

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

@@ -0,0 +1,26 @@
+import type { CmsModel } from "../../../types.js";
+export interface IPermanentlyDeleteEntryParams {
+    model: CmsModel;
+    id: string;
+}
+export interface IPermanentlyDeleteEntryGateway {
+    execute(params: IPermanentlyDeleteEntryParams): Promise<boolean>;
+}
+export declare const PermanentlyDeleteEntryGateway: import("@webiny/di").Abstraction<IPermanentlyDeleteEntryGateway>;
+export declare namespace PermanentlyDeleteEntryGateway {
+    type Interface = IPermanentlyDeleteEntryGateway;
+}
+export interface IPermanentlyDeleteEntryRepository {
+    execute(params: IPermanentlyDeleteEntryParams): Promise<boolean>;
+}
+export declare const PermanentlyDeleteEntryRepository: import("@webiny/di").Abstraction<IPermanentlyDeleteEntryRepository>;
+export declare namespace PermanentlyDeleteEntryRepository {
+    type Interface = IPermanentlyDeleteEntryRepository;
+}
+export interface IPermanentlyDeleteEntryUseCase {
+    execute(params: IPermanentlyDeleteEntryParams): Promise<boolean>;
+}
+export declare const PermanentlyDeleteEntryUseCase: import("@webiny/di").Abstraction<IPermanentlyDeleteEntryUseCase>;
+export declare namespace PermanentlyDeleteEntryUseCase {
+    type Interface = IPermanentlyDeleteEntryUseCase;
+}

package/features/contentEntry/permanentlyDeleteEntry/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/permanentlyDeleteEntry/abstractions.js","sources":["../../../../src/features/contentEntry/permanentlyDeleteEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsModel } from \"~/types.js\";\n\nexport interface IPermanentlyDeleteEntryParams {\n    model: CmsModel;\n    id: string;\n}\n\nexport interface IPermanentlyDeleteEntryGateway {\n    execute(params: IPermanentlyDeleteEntryParams): Promise<boolean>;\n}\n\nexport const PermanentlyDeleteEntryGateway = createAbstraction<IPermanentlyDeleteEntryGateway>(\n    \"PermanentlyDeleteEntryGateway\"\n);\n\nexport namespace PermanentlyDeleteEntryGateway {\n    export type Interface = IPermanentlyDeleteEntryGateway;\n}\n\nexport interface IPermanentlyDeleteEntryRepository {\n    execute(params: IPermanentlyDeleteEntryParams): Promise<boolean>;\n}\n\nexport const PermanentlyDeleteEntryRepository =\n    createAbstraction<IPermanentlyDeleteEntryRepository>(\"PermanentlyDeleteEntryRepository\");\n\nexport namespace PermanentlyDeleteEntryRepository {\n    export type Interface = IPermanentlyDeleteEntryRepository;\n}\n\nexport interface IPermanentlyDeleteEntryUseCase {\n    execute(params: IPermanentlyDeleteEntryParams): Promise<boolean>;\n}\n\nexport const PermanentlyDeleteEntryUseCase = createAbstraction<IPermanentlyDeleteEntryUseCase>(\n    \"PermanentlyDeleteEntryUseCase\"\n);\n\nexport namespace PermanentlyDeleteEntryUseCase {\n    export type Interface = IPermanentlyDeleteEntryUseCase;\n}\n"],"names":["PermanentlyDeleteEntryGateway","createAbstraction","PermanentlyDeleteEntryRepository","PermanentlyDeleteEntryUseCase"],"mappings":";AAYO,MAAMA,gCAAgCC,kBACzC;AAWG,MAAMC,mCACTD,kBAAqD;AAUlD,MAAME,gCAAgCF,kBACzC"}

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

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

package/features/contentEntry/permanentlyDeleteEntry/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { PermanentlyDeleteEntryUseCase } from "./abstractions.js";
+import { PermanentlyDeleteEntryUseCase as external_PermanentlyDeleteEntryUseCase_js_PermanentlyDeleteEntryUseCase } from "./PermanentlyDeleteEntryUseCase.js";
+import { PermanentlyDeleteEntryRepository } from "./PermanentlyDeleteEntryRepository.js";
+import { PermanentlyDeleteEntryGateway } from "./PermanentlyDeleteEntryGateway.js";
+const PermanentlyDeleteEntryFeature = createFeature({
+    name: "CmsContentEntry/PermanentlyDeleteEntry",
+    register (container) {
+        container.register(external_PermanentlyDeleteEntryUseCase_js_PermanentlyDeleteEntryUseCase);
+        container.register(PermanentlyDeleteEntryRepository).inSingletonScope();
+        container.register(PermanentlyDeleteEntryGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(PermanentlyDeleteEntryUseCase)
+        };
+    }
+});
+export { PermanentlyDeleteEntryFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/permanentlyDeleteEntry/feature.js","sources":["../../../../src/features/contentEntry/permanentlyDeleteEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { PermanentlyDeleteEntryUseCase as UseCase } from \"./abstractions.js\";\nimport { PermanentlyDeleteEntryUseCase } from \"./PermanentlyDeleteEntryUseCase.js\";\nimport { PermanentlyDeleteEntryRepository } from \"./PermanentlyDeleteEntryRepository.js\";\nimport { PermanentlyDeleteEntryGateway } from \"./PermanentlyDeleteEntryGateway.js\";\n\nexport const PermanentlyDeleteEntryFeature = createFeature({\n    name: \"CmsContentEntry/PermanentlyDeleteEntry\",\n    register(container) {\n        container.register(PermanentlyDeleteEntryUseCase);\n        container.register(PermanentlyDeleteEntryRepository).inSingletonScope();\n        container.register(PermanentlyDeleteEntryGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["PermanentlyDeleteEntryFeature","createFeature","container","PermanentlyDeleteEntryUseCase","PermanentlyDeleteEntryRepository","PermanentlyDeleteEntryGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,gCAAgCC,cAAc;IACvD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,kCAAkC,gBAAgB;QACrEF,UAAU,QAAQ,CAACG,+BAA+B,gBAAgB;IACtE;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}

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

package/features/contentEntry/publishEntry/PublishEntryGateway.js

@@ -0,0 +1,42 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { PublishEntryGateway } from "./abstractions.js";
+function createMutation(model, fields) {
+    return `
+        mutation CmsPublish${model.singularApiName}($revision: ID!) {
+            content: publish${model.singularApiName}(revision: $revision) {
+                data {
+                    ${fields.getSystemFields(model)}
+                    ${fields.getValuesBlock(model)}
+                }
+                error { message code data }
+            }
+        }`;
+}
+class PublishEntryGatewayImpl {
+    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, error } = response.content;
+        if (!data) throw new Error(error?.message || "Could not publish entry");
+        return data;
+    }
+}
+const PublishEntryGateway_PublishEntryGateway = PublishEntryGateway.createImplementation({
+    implementation: PublishEntryGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient,
+        EntryGraphQLFields
+    ]
+});
+export { PublishEntryGateway_PublishEntryGateway as PublishEntryGateway };
+
+//# sourceMappingURL=PublishEntryGateway.js.map

package/features/contentEntry/publishEntry/PublishEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/publishEntry/PublishEntryGateway.js","sources":["../../../../src/features/contentEntry/publishEntry/PublishEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsContentEntry, CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport { EntryGraphQLFields } from \"../abstractions.js\";\nimport {\n    PublishEntryGateway as GatewayAbstraction,\n    type IPublishEntryParams\n} from \"./abstractions.js\";\n\ninterface PublishEntryResponse {\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 CmsPublish${model.singularApiName}($revision: ID!) {\n            content: publish${model.singularApiName}(revision: $revision) {\n                data {\n                    ${fields.getSystemFields(model)}\n                    ${fields.getValuesBlock(model)}\n                }\n                error { message code data }\n            }\n        }`;\n}\n\nclass PublishEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: CmsGraphQLClient.Interface,\n        private fields: EntryGraphQLFields.Interface\n    ) {}\n\n    async execute({ model, revisionId }: IPublishEntryParams) {\n        const response = await this.client.execute<PublishEntryResponse>({\n            query: createMutation(model, this.fields),\n            variables: { revision: revisionId }\n        });\n\n        const { data, error } = response.content;\n\n        if (!data) {\n            throw new Error(error?.message || \"Could not publish entry\");\n        }\n\n        return data;\n    }\n}\n\nexport const PublishEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: PublishEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient, EntryGraphQLFields]\n});\n"],"names":["createMutation","model","fields","PublishEntryGatewayImpl","client","revisionId","response","data","error","Error","PublishEntryGateway","GatewayAbstraction","CmsGraphQLClient","EntryGraphQLFields"],"mappings":";;;AAeA,SAASA,eAAeC,KAAe,EAAEC,MAAoC;IACzE,OAAqB,CAAC;2BACC,EAAED,MAAM,eAAe,CAAC;4BACvB,EAAEA,MAAM,eAAe,CAAC;;oBAEhC,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,EAAuB,EAAE;QACtD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAuB;YAC7D,OAAON,eAAeC,OAAO,IAAI,CAAC,MAAM;YACxC,WAAW;gBAAE,UAAUI;YAAW;QACtC;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAExC,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,0CAAsBC,oBAAAA,oBAAuC,CAAC;IACvE,gBAAgBR;IAChB,cAAc;QAACS;QAAkBC;KAAmB;AACxD"}

package/features/contentEntry/publishEntry/PublishEntryRepository.d.ts

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

package/features/contentEntry/publishEntry/PublishEntryRepository.js

@@ -0,0 +1,26 @@
+import { PublishEntryGateway, PublishEntryRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "../abstractions.js";
+class PublishEntryRepositoryImpl {
+    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 PublishEntryRepository_PublishEntryRepository = PublishEntryRepository.createImplementation({
+    implementation: PublishEntryRepositoryImpl,
+    dependencies: [
+        ContentEntriesCacheProvider,
+        PublishEntryGateway
+    ]
+});
+export { PublishEntryRepository_PublishEntryRepository as PublishEntryRepository };
+
+//# sourceMappingURL=PublishEntryRepository.js.map

package/features/contentEntry/publishEntry/PublishEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/publishEntry/PublishEntryRepository.js","sources":["../../../../src/features/contentEntry/publishEntry/PublishEntryRepository.ts"],"sourcesContent":["import {\n    PublishEntryRepository as RepositoryAbstraction,\n    PublishEntryGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport type { IPublishEntryParams } from \"./abstractions.js\";\n\nclass PublishEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: PublishEntryGateway.Interface\n    ) {}\n\n    async execute(params: IPublishEntryParams) {\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 PublishEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: PublishEntryRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, PublishEntryGateway]\n});\n"],"names":["PublishEntryRepositoryImpl","cacheProvider","gateway","params","entry","cache","PublishEntryRepository","RepositoryAbstraction","ContentEntriesCacheProvider","PublishEntryGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAAsC,CAChD;aAFUD,aAAa,GAAbA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAA2B,EAAE;QACvC,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,gDAAyBC,uBAAAA,oBAA0C,CAAC;IAC7E,gBAAgBP;IAChB,cAAc;QAACQ;QAA6BC;KAAoB;AACpE"}

package/features/contentEntry/publishEntry/PublishEntryUseCase.d.ts

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

package/features/contentEntry/publishEntry/PublishEntryUseCase.js

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

package/features/contentEntry/publishEntry/PublishEntryUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/publishEntry/PublishEntryUseCase.js","sources":["../../../../src/features/contentEntry/publishEntry/PublishEntryUseCase.ts"],"sourcesContent":["import {\n    PublishEntryUseCase as UseCaseAbstraction,\n    PublishEntryRepository\n} from \"./abstractions.js\";\nimport type { IPublishEntryParams } from \"./abstractions.js\";\n\nclass PublishEntryUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: PublishEntryRepository.Interface) {}\n\n    async execute(params: IPublishEntryParams) {\n        return this.repository.execute(params);\n    }\n}\n\nexport const PublishEntryUseCase = UseCaseAbstraction.createImplementation({\n    implementation: PublishEntryUseCaseImpl,\n    dependencies: [PublishEntryRepository]\n});\n"],"names":["PublishEntryUseCaseImpl","repository","params","PublishEntryUseCase","UseCaseAbstraction","PublishEntryRepository"],"mappings":";AAMA,MAAMA;IACF,YAAoBC,UAA4C,CAAE;aAA9CA,UAAU,GAAVA;IAA+C;IAEnE,MAAM,QAAQC,MAA2B,EAAE;QACvC,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,0CAAsBC,oBAAAA,oBAAuC,CAAC;IACvE,gBAAgBJ;IAChB,cAAc;QAACK;KAAuB;AAC1C"}

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

@@ -0,0 +1,26 @@
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface IPublishEntryParams {
+    model: CmsModel;
+    revisionId: string;
+}
+export interface IPublishEntryGateway {
+    execute(params: IPublishEntryParams): Promise<CmsContentEntry>;
+}
+export declare const PublishEntryGateway: import("@webiny/di").Abstraction<IPublishEntryGateway>;
+export declare namespace PublishEntryGateway {
+    type Interface = IPublishEntryGateway;
+}
+export interface IPublishEntryRepository {
+    execute(params: IPublishEntryParams): Promise<CmsContentEntry>;
+}
+export declare const PublishEntryRepository: import("@webiny/di").Abstraction<IPublishEntryRepository>;
+export declare namespace PublishEntryRepository {
+    type Interface = IPublishEntryRepository;
+}
+export interface IPublishEntryUseCase {
+    execute(params: IPublishEntryParams): Promise<CmsContentEntry>;
+}
+export declare const PublishEntryUseCase: import("@webiny/di").Abstraction<IPublishEntryUseCase>;
+export declare namespace PublishEntryUseCase {
+    type Interface = IPublishEntryUseCase;
+}

package/features/contentEntry/publishEntry/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/publishEntry/abstractions.js","sources":["../../../../src/features/contentEntry/publishEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\nexport interface IPublishEntryParams {\n    model: CmsModel;\n    revisionId: string;\n}\n\nexport interface IPublishEntryGateway {\n    execute(params: IPublishEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const PublishEntryGateway = createAbstraction<IPublishEntryGateway>(\"PublishEntryGateway\");\n\nexport namespace PublishEntryGateway {\n    export type Interface = IPublishEntryGateway;\n}\n\nexport interface IPublishEntryRepository {\n    execute(params: IPublishEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const PublishEntryRepository =\n    createAbstraction<IPublishEntryRepository>(\"PublishEntryRepository\");\n\nexport namespace PublishEntryRepository {\n    export type Interface = IPublishEntryRepository;\n}\n\nexport interface IPublishEntryUseCase {\n    execute(params: IPublishEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const PublishEntryUseCase = createAbstraction<IPublishEntryUseCase>(\"PublishEntryUseCase\");\n\nexport namespace PublishEntryUseCase {\n    export type Interface = IPublishEntryUseCase;\n}\n"],"names":["PublishEntryGateway","createAbstraction","PublishEntryRepository","PublishEntryUseCase"],"mappings":";AAYO,MAAMA,sBAAsBC,kBAAwC;AAUpE,MAAMC,yBACTD,kBAA2C;AAUxC,MAAME,sBAAsBF,kBAAwC"}

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

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

package/features/contentEntry/publishEntry/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { PublishEntryUseCase } from "./abstractions.js";
+import { PublishEntryUseCase as external_PublishEntryUseCase_js_PublishEntryUseCase } from "./PublishEntryUseCase.js";
+import { PublishEntryRepository } from "./PublishEntryRepository.js";
+import { PublishEntryGateway } from "./PublishEntryGateway.js";
+const PublishEntryFeature = createFeature({
+    name: "CmsContentEntry/PublishEntry",
+    register (container) {
+        container.register(external_PublishEntryUseCase_js_PublishEntryUseCase);
+        container.register(PublishEntryRepository).inSingletonScope();
+        container.register(PublishEntryGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(PublishEntryUseCase)
+        };
+    }
+});
+export { PublishEntryFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/publishEntry/feature.js","sources":["../../../../src/features/contentEntry/publishEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { PublishEntryUseCase as UseCase } from \"./abstractions.js\";\nimport { PublishEntryUseCase } from \"./PublishEntryUseCase.js\";\nimport { PublishEntryRepository } from \"./PublishEntryRepository.js\";\nimport { PublishEntryGateway } from \"./PublishEntryGateway.js\";\n\nexport const PublishEntryFeature = createFeature({\n    name: \"CmsContentEntry/PublishEntry\",\n    register(container) {\n        container.register(PublishEntryUseCase);\n        container.register(PublishEntryRepository).inSingletonScope();\n        container.register(PublishEntryGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            useCase: container.resolve(UseCase)\n        };\n    }\n});\n"],"names":["PublishEntryFeature","createFeature","container","PublishEntryUseCase","PublishEntryRepository","PublishEntryGateway","UseCase"],"mappings":";;;;;AAMO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,wBAAwB,gBAAgB;QAC3DF,UAAU,QAAQ,CAACG,qBAAqB,gBAAgB;IAC5D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,SAASA,UAAU,OAAO,CAACI;QAC/B;IACJ;AACJ"}