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

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

@@ -0,0 +1,4 @@
+export declare const SingletonEntryFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    getUseCase: import("./abstractions.js").IGetSingletonEntryUseCase;
+    updateUseCase: import("./abstractions.js").IUpdateSingletonEntryUseCase;
+}, []>;

package/features/contentEntry/singletonEntry/feature.js

@@ -0,0 +1,24 @@
+import { createFeature } from "@webiny/feature/admin";
+import { GetSingletonEntryUseCase, UpdateSingletonEntryUseCase } from "./abstractions.js";
+import { GetSingletonEntryUseCase as external_GetSingletonEntryUseCase_js_GetSingletonEntryUseCase } from "./GetSingletonEntryUseCase.js";
+import { GetSingletonEntryGateway } from "./GetSingletonEntryGateway.js";
+import { UpdateSingletonEntryUseCase as external_UpdateSingletonEntryUseCase_js_UpdateSingletonEntryUseCase } from "./UpdateSingletonEntryUseCase.js";
+import { UpdateSingletonEntryGateway } from "./UpdateSingletonEntryGateway.js";
+const SingletonEntryFeature = createFeature({
+    name: "CmsContentEntry/SingletonEntry",
+    register (container) {
+        container.register(external_GetSingletonEntryUseCase_js_GetSingletonEntryUseCase);
+        container.register(GetSingletonEntryGateway).inSingletonScope();
+        container.register(external_UpdateSingletonEntryUseCase_js_UpdateSingletonEntryUseCase);
+        container.register(UpdateSingletonEntryGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            getUseCase: container.resolve(GetSingletonEntryUseCase),
+            updateUseCase: container.resolve(UpdateSingletonEntryUseCase)
+        };
+    }
+});
+export { SingletonEntryFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/singletonEntry/feature.js","sources":["../../../../src/features/contentEntry/singletonEntry/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport {\n    GetSingletonEntryUseCase as GetUseCase,\n    UpdateSingletonEntryUseCase as UpdateUseCase\n} from \"./abstractions.js\";\nimport { GetSingletonEntryUseCase } from \"./GetSingletonEntryUseCase.js\";\nimport { GetSingletonEntryGateway } from \"./GetSingletonEntryGateway.js\";\nimport { UpdateSingletonEntryUseCase } from \"./UpdateSingletonEntryUseCase.js\";\nimport { UpdateSingletonEntryGateway } from \"./UpdateSingletonEntryGateway.js\";\n\nexport const SingletonEntryFeature = createFeature({\n    name: \"CmsContentEntry/SingletonEntry\",\n    register(container) {\n        container.register(GetSingletonEntryUseCase);\n        container.register(GetSingletonEntryGateway).inSingletonScope();\n        container.register(UpdateSingletonEntryUseCase);\n        container.register(UpdateSingletonEntryGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            getUseCase: container.resolve(GetUseCase),\n            updateUseCase: container.resolve(UpdateUseCase)\n        };\n    }\n});\n"],"names":["SingletonEntryFeature","createFeature","container","GetSingletonEntryUseCase","GetSingletonEntryGateway","UpdateSingletonEntryUseCase","UpdateSingletonEntryGateway","GetUseCase","UpdateUseCase"],"mappings":";;;;;;AAUO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,0BAA0B,gBAAgB;QAC7DF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI,6BAA6B,gBAAgB;IACpE;IACA,SAAQJ,SAAS;QACb,OAAO;YACH,YAAYA,UAAU,OAAO,CAACK;YAC9B,eAAeL,UAAU,OAAO,CAACM;QACrC;IACJ;AACJ"}

package/features/contentEntry/trashBin/CmsTrashBinGatewayAdapter.d.ts

@@ -0,0 +1,46 @@
+import type { ITrashBinListGateway, ITrashBinListGatewayParams, ITrashBinListGatewayResult, ITrashBinDeleteGateway, ITrashBinRestoreGateway, ITrashBinBulkActionGateway, ITrashBinBulkActionParams, ITrashBinBulkActionResult, TrashBinItem } from "@webiny/app-admin/presentation/trashBin/abstractions.js";
+import { CmsModelContext } from "../../../features/contentEntry/abstractions.js";
+import { ListDeletedEntriesUseCase } from "../../../features/contentEntry/listDeletedEntries/abstractions.js";
+import { RestoreFromTrashUseCase } from "../../../features/contentEntry/restoreFromTrash/abstractions.js";
+import { PermanentlyDeleteEntryUseCase } from "../../../features/contentEntry/permanentlyDeleteEntry/abstractions.js";
+import { BulkActionUseCase } from "../../../features/contentEntry/bulkAction/abstractions.js";
+import { type ICmsTrashBinItemMapper } from "./abstractions.js";
+declare class CmsTrashBinListGatewayAdapterImpl implements ITrashBinListGateway {
+    private listDeletedEntriesUseCase;
+    private itemMapper;
+    private modelAccessor;
+    constructor(listDeletedEntriesUseCase: ListDeletedEntriesUseCase.Interface, itemMapper: ICmsTrashBinItemMapper, modelAccessor: CmsModelContext.Interface);
+    execute(params: ITrashBinListGatewayParams): Promise<ITrashBinListGatewayResult>;
+}
+export declare const CmsTrashBinListGatewayAdapter: typeof CmsTrashBinListGatewayAdapterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ITrashBinListGateway>;
+};
+declare class CmsTrashBinDeleteGatewayAdapterImpl implements ITrashBinDeleteGateway {
+    private permanentlyDeleteUseCase;
+    private modelAccessor;
+    constructor(permanentlyDeleteUseCase: PermanentlyDeleteEntryUseCase.Interface, modelAccessor: CmsModelContext.Interface);
+    execute(id: string): Promise<boolean>;
+}
+export declare const CmsTrashBinDeleteGatewayAdapter: typeof CmsTrashBinDeleteGatewayAdapterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ITrashBinDeleteGateway>;
+};
+declare class CmsTrashBinRestoreGatewayAdapterImpl implements ITrashBinRestoreGateway {
+    private restoreFromTrashUseCase;
+    private itemMapper;
+    private modelAccessor;
+    constructor(restoreFromTrashUseCase: RestoreFromTrashUseCase.Interface, itemMapper: ICmsTrashBinItemMapper, modelAccessor: CmsModelContext.Interface);
+    execute(id: string): Promise<TrashBinItem>;
+}
+export declare const CmsTrashBinRestoreGatewayAdapter: typeof CmsTrashBinRestoreGatewayAdapterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ITrashBinRestoreGateway>;
+};
+declare class CmsTrashBinBulkActionGatewayAdapterImpl implements ITrashBinBulkActionGateway {
+    private bulkActionUseCase;
+    private modelAccessor;
+    constructor(bulkActionUseCase: BulkActionUseCase.Interface, modelAccessor: CmsModelContext.Interface);
+    execute(params: ITrashBinBulkActionParams): Promise<ITrashBinBulkActionResult>;
+}
+export declare const CmsTrashBinBulkActionGatewayAdapter: typeof CmsTrashBinBulkActionGatewayAdapterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ITrashBinBulkActionGateway>;
+};
+export {};

package/features/contentEntry/trashBin/CmsTrashBinGatewayAdapter.js

@@ -0,0 +1,109 @@
+import { TrashBinBulkActionGateway, TrashBinDeleteGateway, TrashBinListGateway, TrashBinRestoreGateway } from "@webiny/app-admin/presentation/trashBin/abstractions.js";
+import { CmsModelContext } from "../abstractions.js";
+import { ListDeletedEntriesUseCase } from "../listDeletedEntries/abstractions.js";
+import { RestoreFromTrashUseCase } from "../restoreFromTrash/abstractions.js";
+import { PermanentlyDeleteEntryUseCase } from "../permanentlyDeleteEntry/abstractions.js";
+import { BulkActionUseCase } from "../bulkAction/abstractions.js";
+import { CmsTrashBinItemMapper } from "./abstractions.js";
+class CmsTrashBinListGatewayAdapterImpl {
+    constructor(listDeletedEntriesUseCase, itemMapper, modelAccessor){
+        this.listDeletedEntriesUseCase = listDeletedEntriesUseCase;
+        this.itemMapper = itemMapper;
+        this.modelAccessor = modelAccessor;
+    }
+    async execute(params) {
+        const model = this.modelAccessor.getModel();
+        const result = await this.listDeletedEntriesUseCase.execute({
+            model,
+            where: params.where,
+            sort: params.sort,
+            limit: params.limit,
+            after: params.after,
+            search: params.search
+        });
+        return {
+            data: result.data.map((entry)=>this.itemMapper.toItem(entry)),
+            meta: {
+                cursor: result.meta.cursor,
+                hasMoreItems: result.meta.hasMoreItems,
+                totalCount: result.meta.totalCount
+            }
+        };
+    }
+}
+const CmsTrashBinListGatewayAdapter = TrashBinListGateway.createImplementation({
+    implementation: CmsTrashBinListGatewayAdapterImpl,
+    dependencies: [
+        ListDeletedEntriesUseCase,
+        CmsTrashBinItemMapper,
+        CmsModelContext
+    ]
+});
+class CmsTrashBinDeleteGatewayAdapterImpl {
+    constructor(permanentlyDeleteUseCase, modelAccessor){
+        this.permanentlyDeleteUseCase = permanentlyDeleteUseCase;
+        this.modelAccessor = modelAccessor;
+    }
+    async execute(id) {
+        const model = this.modelAccessor.getModel();
+        return this.permanentlyDeleteUseCase.execute({
+            model,
+            id
+        });
+    }
+}
+const CmsTrashBinDeleteGatewayAdapter = TrashBinDeleteGateway.createImplementation({
+    implementation: CmsTrashBinDeleteGatewayAdapterImpl,
+    dependencies: [
+        PermanentlyDeleteEntryUseCase,
+        CmsModelContext
+    ]
+});
+class CmsTrashBinRestoreGatewayAdapterImpl {
+    constructor(restoreFromTrashUseCase, itemMapper, modelAccessor){
+        this.restoreFromTrashUseCase = restoreFromTrashUseCase;
+        this.itemMapper = itemMapper;
+        this.modelAccessor = modelAccessor;
+    }
+    async execute(id) {
+        const model = this.modelAccessor.getModel();
+        const entry = await this.restoreFromTrashUseCase.execute({
+            model,
+            id
+        });
+        return this.itemMapper.toItem(entry);
+    }
+}
+const CmsTrashBinRestoreGatewayAdapter = TrashBinRestoreGateway.createImplementation({
+    implementation: CmsTrashBinRestoreGatewayAdapterImpl,
+    dependencies: [
+        RestoreFromTrashUseCase,
+        CmsTrashBinItemMapper,
+        CmsModelContext
+    ]
+});
+class CmsTrashBinBulkActionGatewayAdapterImpl {
+    constructor(bulkActionUseCase, modelAccessor){
+        this.bulkActionUseCase = bulkActionUseCase;
+        this.modelAccessor = modelAccessor;
+    }
+    async execute(params) {
+        const model = this.modelAccessor.getModel();
+        return this.bulkActionUseCase.execute({
+            model,
+            action: params.action,
+            where: params.where,
+            search: params.search
+        });
+    }
+}
+const CmsTrashBinBulkActionGatewayAdapter = TrashBinBulkActionGateway.createImplementation({
+    implementation: CmsTrashBinBulkActionGatewayAdapterImpl,
+    dependencies: [
+        BulkActionUseCase,
+        CmsModelContext
+    ]
+});
+export { CmsTrashBinBulkActionGatewayAdapter, CmsTrashBinDeleteGatewayAdapter, CmsTrashBinListGatewayAdapter, CmsTrashBinRestoreGatewayAdapter };
+
+//# sourceMappingURL=CmsTrashBinGatewayAdapter.js.map

package/features/contentEntry/trashBin/CmsTrashBinGatewayAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/trashBin/CmsTrashBinGatewayAdapter.js","sources":["../../../../src/features/contentEntry/trashBin/CmsTrashBinGatewayAdapter.ts"],"sourcesContent":["import type {\n    ITrashBinListGateway,\n    ITrashBinListGatewayParams,\n    ITrashBinListGatewayResult,\n    ITrashBinDeleteGateway,\n    ITrashBinRestoreGateway,\n    ITrashBinBulkActionGateway,\n    ITrashBinBulkActionParams,\n    ITrashBinBulkActionResult,\n    TrashBinItem\n} from \"@webiny/app-admin/presentation/trashBin/abstractions.js\";\nimport {\n    TrashBinListGateway,\n    TrashBinDeleteGateway,\n    TrashBinRestoreGateway,\n    TrashBinBulkActionGateway\n} from \"@webiny/app-admin/presentation/trashBin/abstractions.js\";\nimport { CmsModelContext } from \"~/features/contentEntry/abstractions.js\";\nimport { ListDeletedEntriesUseCase } from \"~/features/contentEntry/listDeletedEntries/abstractions.js\";\nimport { RestoreFromTrashUseCase } from \"~/features/contentEntry/restoreFromTrash/abstractions.js\";\nimport { PermanentlyDeleteEntryUseCase } from \"~/features/contentEntry/permanentlyDeleteEntry/abstractions.js\";\nimport { BulkActionUseCase } from \"~/features/contentEntry/bulkAction/abstractions.js\";\nimport { CmsTrashBinItemMapper, type ICmsTrashBinItemMapper } from \"./abstractions.js\";\n\nclass CmsTrashBinListGatewayAdapterImpl implements ITrashBinListGateway {\n    constructor(\n        private listDeletedEntriesUseCase: ListDeletedEntriesUseCase.Interface,\n        private itemMapper: ICmsTrashBinItemMapper,\n        private modelAccessor: CmsModelContext.Interface\n    ) {}\n\n    async execute(params: ITrashBinListGatewayParams): Promise<ITrashBinListGatewayResult> {\n        const model = this.modelAccessor.getModel();\n\n        const result = await this.listDeletedEntriesUseCase.execute({\n            model,\n            where: params.where,\n            sort: params.sort,\n            limit: params.limit,\n            after: params.after,\n            search: params.search\n        });\n\n        return {\n            data: result.data.map(entry => this.itemMapper.toItem(entry)),\n            meta: {\n                cursor: result.meta.cursor,\n                hasMoreItems: result.meta.hasMoreItems,\n                totalCount: result.meta.totalCount\n            }\n        };\n    }\n}\n\nexport const CmsTrashBinListGatewayAdapter = TrashBinListGateway.createImplementation({\n    implementation: CmsTrashBinListGatewayAdapterImpl,\n    dependencies: [ListDeletedEntriesUseCase, CmsTrashBinItemMapper, CmsModelContext]\n});\n\nclass CmsTrashBinDeleteGatewayAdapterImpl implements ITrashBinDeleteGateway {\n    constructor(\n        private permanentlyDeleteUseCase: PermanentlyDeleteEntryUseCase.Interface,\n        private modelAccessor: CmsModelContext.Interface\n    ) {}\n\n    async execute(id: string): Promise<boolean> {\n        const model = this.modelAccessor.getModel();\n        return this.permanentlyDeleteUseCase.execute({ model, id });\n    }\n}\n\nexport const CmsTrashBinDeleteGatewayAdapter = TrashBinDeleteGateway.createImplementation({\n    implementation: CmsTrashBinDeleteGatewayAdapterImpl,\n    dependencies: [PermanentlyDeleteEntryUseCase, CmsModelContext]\n});\n\nclass CmsTrashBinRestoreGatewayAdapterImpl implements ITrashBinRestoreGateway {\n    constructor(\n        private restoreFromTrashUseCase: RestoreFromTrashUseCase.Interface,\n        private itemMapper: ICmsTrashBinItemMapper,\n        private modelAccessor: CmsModelContext.Interface\n    ) {}\n\n    async execute(id: string): Promise<TrashBinItem> {\n        const model = this.modelAccessor.getModel();\n        const entry = await this.restoreFromTrashUseCase.execute({ model, id });\n        return this.itemMapper.toItem(entry);\n    }\n}\n\nexport const CmsTrashBinRestoreGatewayAdapter = TrashBinRestoreGateway.createImplementation({\n    implementation: CmsTrashBinRestoreGatewayAdapterImpl,\n    dependencies: [RestoreFromTrashUseCase, CmsTrashBinItemMapper, CmsModelContext]\n});\n\nclass CmsTrashBinBulkActionGatewayAdapterImpl implements ITrashBinBulkActionGateway {\n    constructor(\n        private bulkActionUseCase: BulkActionUseCase.Interface,\n        private modelAccessor: CmsModelContext.Interface\n    ) {}\n\n    async execute(params: ITrashBinBulkActionParams): Promise<ITrashBinBulkActionResult> {\n        const model = this.modelAccessor.getModel();\n\n        return this.bulkActionUseCase.execute({\n            model,\n            action: params.action,\n            where: params.where,\n            search: params.search\n        });\n    }\n}\n\nexport const CmsTrashBinBulkActionGatewayAdapter = TrashBinBulkActionGateway.createImplementation({\n    implementation: CmsTrashBinBulkActionGatewayAdapterImpl,\n    dependencies: [BulkActionUseCase, CmsModelContext]\n});\n"],"names":["CmsTrashBinListGatewayAdapterImpl","listDeletedEntriesUseCase","itemMapper","modelAccessor","params","model","result","entry","CmsTrashBinListGatewayAdapter","TrashBinListGateway","ListDeletedEntriesUseCase","CmsTrashBinItemMapper","CmsModelContext","CmsTrashBinDeleteGatewayAdapterImpl","permanentlyDeleteUseCase","id","CmsTrashBinDeleteGatewayAdapter","TrashBinDeleteGateway","PermanentlyDeleteEntryUseCase","CmsTrashBinRestoreGatewayAdapterImpl","restoreFromTrashUseCase","CmsTrashBinRestoreGatewayAdapter","TrashBinRestoreGateway","RestoreFromTrashUseCase","CmsTrashBinBulkActionGatewayAdapterImpl","bulkActionUseCase","CmsTrashBinBulkActionGatewayAdapter","TrashBinBulkActionGateway","BulkActionUseCase"],"mappings":";;;;;;;AAwBA,MAAMA;IACF,YACYC,yBAA8D,EAC9DC,UAAkC,EAClCC,aAAwC,CAClD;aAHUF,yBAAyB,GAAzBA;aACAC,UAAU,GAAVA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,MAAkC,EAAuC;QACnF,MAAMC,QAAQ,IAAI,CAAC,aAAa,CAAC,QAAQ;QAEzC,MAAMC,SAAS,MAAM,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC;YACxDD;YACA,OAAOD,OAAO,KAAK;YACnB,MAAMA,OAAO,IAAI;YACjB,OAAOA,OAAO,KAAK;YACnB,OAAOA,OAAO,KAAK;YACnB,QAAQA,OAAO,MAAM;QACzB;QAEA,OAAO;YACH,MAAME,OAAO,IAAI,CAAC,GAAG,CAACC,CAAAA,QAAS,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;YACtD,MAAM;gBACF,QAAQD,OAAO,IAAI,CAAC,MAAM;gBAC1B,cAAcA,OAAO,IAAI,CAAC,YAAY;gBACtC,YAAYA,OAAO,IAAI,CAAC,UAAU;YACtC;QACJ;IACJ;AACJ;AAEO,MAAME,gCAAgCC,oBAAoB,oBAAoB,CAAC;IAClF,gBAAgBT;IAChB,cAAc;QAACU;QAA2BC;QAAuBC;KAAgB;AACrF;AAEA,MAAMC;IACF,YACYC,wBAAiE,EACjEX,aAAwC,CAClD;aAFUW,wBAAwB,GAAxBA;aACAX,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQY,EAAU,EAAoB;QACxC,MAAMV,QAAQ,IAAI,CAAC,aAAa,CAAC,QAAQ;QACzC,OAAO,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC;YAAEA;YAAOU;QAAG;IAC7D;AACJ;AAEO,MAAMC,kCAAkCC,sBAAsB,oBAAoB,CAAC;IACtF,gBAAgBJ;IAChB,cAAc;QAACK;QAA+BN;KAAgB;AAClE;AAEA,MAAMO;IACF,YACYC,uBAA0D,EAC1DlB,UAAkC,EAClCC,aAAwC,CAClD;aAHUiB,uBAAuB,GAAvBA;aACAlB,UAAU,GAAVA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQY,EAAU,EAAyB;QAC7C,MAAMV,QAAQ,IAAI,CAAC,aAAa,CAAC,QAAQ;QACzC,MAAME,QAAQ,MAAM,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC;YAAEF;YAAOU;QAAG;QACrE,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAACR;IAClC;AACJ;AAEO,MAAMc,mCAAmCC,uBAAuB,oBAAoB,CAAC;IACxF,gBAAgBH;IAChB,cAAc;QAACI;QAAyBZ;QAAuBC;KAAgB;AACnF;AAEA,MAAMY;IACF,YACYC,iBAA8C,EAC9CtB,aAAwC,CAClD;aAFUsB,iBAAiB,GAAjBA;aACAtB,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,MAAiC,EAAsC;QACjF,MAAMC,QAAQ,IAAI,CAAC,aAAa,CAAC,QAAQ;QAEzC,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC;YAClCA;YACA,QAAQD,OAAO,MAAM;YACrB,OAAOA,OAAO,KAAK;YACnB,QAAQA,OAAO,MAAM;QACzB;IACJ;AACJ;AAEO,MAAMsB,sCAAsCC,0BAA0B,oBAAoB,CAAC;IAC9F,gBAAgBH;IAChB,cAAc;QAACI;QAAmBhB;KAAgB;AACtD"}

package/features/contentEntry/trashBin/CmsTrashBinItemMapper.d.ts

@@ -0,0 +1,10 @@
+import type { TrashBinItem } from "@webiny/app-admin/presentation/trashBin/abstractions.js";
+import type { CmsContentEntry } from "../../../types.js";
+import { type ICmsTrashBinItemMapper } from "./abstractions.js";
+declare class CmsTrashBinItemMapperImpl implements ICmsTrashBinItemMapper {
+    toItem(entry: CmsContentEntry): TrashBinItem;
+}
+export declare const CmsTrashBinItemMapper: typeof CmsTrashBinItemMapperImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ICmsTrashBinItemMapper>;
+};
+export {};

package/features/contentEntry/trashBin/CmsTrashBinItemMapper.js

@@ -0,0 +1,24 @@
+import { CmsTrashBinItemMapper } from "./abstractions.js";
+class CmsTrashBinItemMapperImpl {
+    toItem(entry) {
+        return {
+            id: entry.entryId,
+            title: entry.meta.title,
+            location: entry.wbyAco_location,
+            createdBy: entry.createdBy,
+            deletedBy: {
+                id: entry.deletedBy?.id || "",
+                displayName: entry.deletedBy?.displayName || "",
+                type: entry.deletedBy?.type || ""
+            },
+            deletedOn: entry.deletedOn || ""
+        };
+    }
+}
+const CmsTrashBinItemMapper_CmsTrashBinItemMapper = CmsTrashBinItemMapper.createImplementation({
+    implementation: CmsTrashBinItemMapperImpl,
+    dependencies: []
+});
+export { CmsTrashBinItemMapper_CmsTrashBinItemMapper as CmsTrashBinItemMapper };
+
+//# sourceMappingURL=CmsTrashBinItemMapper.js.map

package/features/contentEntry/trashBin/CmsTrashBinItemMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/trashBin/CmsTrashBinItemMapper.js","sources":["../../../../src/features/contentEntry/trashBin/CmsTrashBinItemMapper.ts"],"sourcesContent":["import type { TrashBinItem } from \"@webiny/app-admin/presentation/trashBin/abstractions.js\";\nimport type { CmsContentEntry } from \"~/types.js\";\nimport {\n    CmsTrashBinItemMapper as Abstraction,\n    type ICmsTrashBinItemMapper\n} from \"./abstractions.js\";\n\nclass CmsTrashBinItemMapperImpl implements ICmsTrashBinItemMapper {\n    toItem(entry: CmsContentEntry): TrashBinItem {\n        return {\n            id: entry.entryId,\n            title: entry.meta.title,\n            location: entry.wbyAco_location,\n            createdBy: entry.createdBy,\n            deletedBy: {\n                id: entry.deletedBy?.id || \"\",\n                displayName: entry.deletedBy?.displayName || \"\",\n                type: entry.deletedBy?.type || \"\"\n            },\n            deletedOn: entry.deletedOn || \"\"\n        };\n    }\n}\n\nexport const CmsTrashBinItemMapper = Abstraction.createImplementation({\n    implementation: CmsTrashBinItemMapperImpl,\n    dependencies: []\n});\n"],"names":["CmsTrashBinItemMapperImpl","entry","CmsTrashBinItemMapper","Abstraction"],"mappings":";AAOA,MAAMA;IACF,OAAOC,KAAsB,EAAgB;QACzC,OAAO;YACH,IAAIA,MAAM,OAAO;YACjB,OAAOA,MAAM,IAAI,CAAC,KAAK;YACvB,UAAUA,MAAM,eAAe;YAC/B,WAAWA,MAAM,SAAS;YAC1B,WAAW;gBACP,IAAIA,MAAM,SAAS,EAAE,MAAM;gBAC3B,aAAaA,MAAM,SAAS,EAAE,eAAe;gBAC7C,MAAMA,MAAM,SAAS,EAAE,QAAQ;YACnC;YACA,WAAWA,MAAM,SAAS,IAAI;QAClC;IACJ;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAAgC,CAAC;IAClE,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,9 @@
+import type { TrashBinItem } from "@webiny/app-admin/presentation/trashBin/abstractions.js";
+import type { CmsContentEntry } from "../../../types.js";
+export interface ICmsTrashBinItemMapper {
+    toItem(entry: CmsContentEntry): TrashBinItem;
+}
+export declare const CmsTrashBinItemMapper: import("@webiny/di").Abstraction<ICmsTrashBinItemMapper>;
+export declare namespace CmsTrashBinItemMapper {
+    type Interface = ICmsTrashBinItemMapper;
+}

package/features/contentEntry/trashBin/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/trashBin/abstractions.js","sources":["../../../../src/features/contentEntry/trashBin/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { TrashBinItem } from \"@webiny/app-admin/presentation/trashBin/abstractions.js\";\nimport type { CmsContentEntry } from \"~/types.js\";\n\nexport interface ICmsTrashBinItemMapper {\n    toItem(entry: CmsContentEntry): TrashBinItem;\n}\n\nexport const CmsTrashBinItemMapper =\n    createAbstraction<ICmsTrashBinItemMapper>(\"CmsTrashBinItemMapper\");\n\nexport namespace CmsTrashBinItemMapper {\n    export type Interface = ICmsTrashBinItemMapper;\n}\n"],"names":["CmsTrashBinItemMapper","createAbstraction"],"mappings":";AAQO,MAAMA,wBACTC,kBAA0C"}

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

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

package/features/contentEntry/trashBin/feature.js

@@ -0,0 +1,24 @@
+import { createFeature } from "@webiny/feature/admin";
+import { TrashBinFeature } from "@webiny/app-admin/presentation/trashBin/feature.js";
+import { ListDeletedEntriesFeature } from "../listDeletedEntries/feature.js";
+import { RestoreFromTrashFeature } from "../restoreFromTrash/feature.js";
+import { PermanentlyDeleteEntryFeature } from "../permanentlyDeleteEntry/feature.js";
+import { CmsTrashBinItemMapper } from "./CmsTrashBinItemMapper.js";
+import { CmsTrashBinBulkActionGatewayAdapter, CmsTrashBinDeleteGatewayAdapter, CmsTrashBinListGatewayAdapter, CmsTrashBinRestoreGatewayAdapter } from "./CmsTrashBinGatewayAdapter.js";
+const CmsTrashBinFeature = createFeature({
+    name: "CmsContentEntry/TrashBin",
+    register (container) {
+        ListDeletedEntriesFeature.register(container);
+        RestoreFromTrashFeature.register(container);
+        PermanentlyDeleteEntryFeature.register(container);
+        container.register(CmsTrashBinItemMapper).inSingletonScope();
+        container.register(CmsTrashBinListGatewayAdapter).inSingletonScope();
+        container.register(CmsTrashBinDeleteGatewayAdapter).inSingletonScope();
+        container.register(CmsTrashBinRestoreGatewayAdapter).inSingletonScope();
+        container.register(CmsTrashBinBulkActionGatewayAdapter).inSingletonScope();
+        TrashBinFeature.register(container);
+    }
+});
+export { CmsTrashBinFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/trashBin/feature.js","sources":["../../../../src/features/contentEntry/trashBin/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { TrashBinFeature } from \"@webiny/app-admin/presentation/trashBin/feature.js\";\nimport { ListDeletedEntriesFeature } from \"~/features/contentEntry/listDeletedEntries/feature.js\";\nimport { RestoreFromTrashFeature } from \"~/features/contentEntry/restoreFromTrash/feature.js\";\nimport { PermanentlyDeleteEntryFeature } from \"~/features/contentEntry/permanentlyDeleteEntry/feature.js\";\nimport { CmsTrashBinItemMapper } from \"./CmsTrashBinItemMapper.js\";\nimport {\n    CmsTrashBinListGatewayAdapter,\n    CmsTrashBinDeleteGatewayAdapter,\n    CmsTrashBinRestoreGatewayAdapter,\n    CmsTrashBinBulkActionGatewayAdapter\n} from \"./CmsTrashBinGatewayAdapter.js\";\n\nexport const CmsTrashBinFeature = createFeature({\n    name: \"CmsContentEntry/TrashBin\",\n    register(container) {\n        ListDeletedEntriesFeature.register(container);\n        RestoreFromTrashFeature.register(container);\n        PermanentlyDeleteEntryFeature.register(container);\n\n        container.register(CmsTrashBinItemMapper).inSingletonScope();\n\n        container.register(CmsTrashBinListGatewayAdapter).inSingletonScope();\n        container.register(CmsTrashBinDeleteGatewayAdapter).inSingletonScope();\n        container.register(CmsTrashBinRestoreGatewayAdapter).inSingletonScope();\n        container.register(CmsTrashBinBulkActionGatewayAdapter).inSingletonScope();\n\n        TrashBinFeature.register(container);\n    }\n});\n"],"names":["CmsTrashBinFeature","createFeature","container","ListDeletedEntriesFeature","RestoreFromTrashFeature","PermanentlyDeleteEntryFeature","CmsTrashBinItemMapper","CmsTrashBinListGatewayAdapter","CmsTrashBinDeleteGatewayAdapter","CmsTrashBinRestoreGatewayAdapter","CmsTrashBinBulkActionGatewayAdapter","TrashBinFeature"],"mappings":";;;;;;;AAaO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QACdC,0BAA0B,QAAQ,CAACD;QACnCE,wBAAwB,QAAQ,CAACF;QACjCG,8BAA8B,QAAQ,CAACH;QAEvCA,UAAU,QAAQ,CAACI,uBAAuB,gBAAgB;QAE1DJ,UAAU,QAAQ,CAACK,+BAA+B,gBAAgB;QAClEL,UAAU,QAAQ,CAACM,iCAAiC,gBAAgB;QACpEN,UAAU,QAAQ,CAACO,kCAAkC,gBAAgB;QACrEP,UAAU,QAAQ,CAACQ,qCAAqC,gBAAgB;QAExEC,gBAAgB,QAAQ,CAACT;IAC7B;AACJ"}

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

@@ -0,0 +1 @@
+export { CmsTrashBinFeature } from "./feature.js";

package/features/contentEntry/trashBin/index.js

@@ -0,0 +1 @@
+export { CmsTrashBinFeature } from "./feature.js";

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

package/features/contentEntry/unpublishEntry/UnpublishEntryGateway.js

@@ -0,0 +1,42 @@
+import { CmsGraphQLClient } from "../../graphQLClient/abstractions.js";
+import { EntryGraphQLFields } from "../abstractions.js";
+import { UnpublishEntryGateway } from "./abstractions.js";
+function createMutation(model, fields) {
+    return `
+        mutation CmsUnpublish${model.singularApiName}($revision: ID!) {
+            content: unpublish${model.singularApiName}(revision: $revision) {
+                data {
+                    ${fields.getSystemFields(model)}
+                    ${fields.getValuesBlock(model)}
+                }
+                error { message code data }
+            }
+        }`;
+}
+class UnpublishEntryGatewayImpl {
+    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 unpublish entry");
+        return data;
+    }
+}
+const UnpublishEntryGateway_UnpublishEntryGateway = UnpublishEntryGateway.createImplementation({
+    implementation: UnpublishEntryGatewayImpl,
+    dependencies: [
+        CmsGraphQLClient,
+        EntryGraphQLFields
+    ]
+});
+export { UnpublishEntryGateway_UnpublishEntryGateway as UnpublishEntryGateway };
+
+//# sourceMappingURL=UnpublishEntryGateway.js.map

package/features/contentEntry/unpublishEntry/UnpublishEntryGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/unpublishEntry/UnpublishEntryGateway.js","sources":["../../../../src/features/contentEntry/unpublishEntry/UnpublishEntryGateway.ts"],"sourcesContent":["import { CmsGraphQLClient } from \"~/features/graphQLClient/abstractions.js\";\nimport type { CmsContentEntry, CmsErrorResponse, CmsModel } from \"~/types.js\";\nimport { EntryGraphQLFields } from \"../abstractions.js\";\nimport {\n    UnpublishEntryGateway as GatewayAbstraction,\n    type IUnpublishEntryParams\n} from \"./abstractions.js\";\n\ninterface UnpublishEntryResponse {\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 CmsUnpublish${model.singularApiName}($revision: ID!) {\n            content: unpublish${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 UnpublishEntryGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(\n        private client: CmsGraphQLClient.Interface,\n        private fields: EntryGraphQLFields.Interface\n    ) {}\n\n    async execute({ model, revisionId }: IUnpublishEntryParams) {\n        const response = await this.client.execute<UnpublishEntryResponse>({\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 unpublish entry\");\n        }\n\n        return data;\n    }\n}\n\nexport const UnpublishEntryGateway = GatewayAbstraction.createImplementation({\n    implementation: UnpublishEntryGatewayImpl,\n    dependencies: [CmsGraphQLClient, EntryGraphQLFields]\n});\n"],"names":["createMutation","model","fields","UnpublishEntryGatewayImpl","client","revisionId","response","data","error","Error","UnpublishEntryGateway","GatewayAbstraction","CmsGraphQLClient","EntryGraphQLFields"],"mappings":";;;AAeA,SAASA,eAAeC,KAAe,EAAEC,MAAoC;IACzE,OAAqB,CAAC;6BACG,EAAED,MAAM,eAAe,CAAC;8BACvB,EAAEA,MAAM,eAAe,CAAC;;oBAElC,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,EAAyB,EAAE;QACxD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAyB;YAC/D,OAAON,eAAeC,OAAO,IAAI,CAAC,MAAM;YACxC,WAAW;gBAAE,UAAUI;YAAW;QACtC;QAEA,MAAM,EAAEE,IAAI,EAAEC,KAAK,EAAE,GAAGF,SAAS,OAAO;QAExC,IAAI,CAACC,MACD,MAAM,IAAIE,MAAMD,OAAO,WAAW;QAGtC,OAAOD;IACX;AACJ;AAEO,MAAMG,8CAAwBC,sBAAAA,oBAAuC,CAAC;IACzE,gBAAgBR;IAChB,cAAc;QAACS;QAAkBC;KAAmB;AACxD"}

package/features/contentEntry/unpublishEntry/UnpublishEntryRepository.d.ts

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

package/features/contentEntry/unpublishEntry/UnpublishEntryRepository.js

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

package/features/contentEntry/unpublishEntry/UnpublishEntryRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/unpublishEntry/UnpublishEntryRepository.js","sources":["../../../../src/features/contentEntry/unpublishEntry/UnpublishEntryRepository.ts"],"sourcesContent":["import {\n    UnpublishEntryRepository as RepositoryAbstraction,\n    UnpublishEntryGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"~/features/contentEntry/abstractions.js\";\nimport type { IUnpublishEntryParams } from \"./abstractions.js\";\n\nclass UnpublishEntryRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private cacheProvider: ContentEntriesCacheProvider.Interface,\n        private gateway: UnpublishEntryGateway.Interface\n    ) {}\n\n    async execute(params: IUnpublishEntryParams) {\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 UnpublishEntryRepository = RepositoryAbstraction.createImplementation({\n    implementation: UnpublishEntryRepositoryImpl,\n    dependencies: [ContentEntriesCacheProvider, UnpublishEntryGateway]\n});\n"],"names":["UnpublishEntryRepositoryImpl","cacheProvider","gateway","params","entry","cache","UnpublishEntryRepository","RepositoryAbstraction","ContentEntriesCacheProvider","UnpublishEntryGateway"],"mappings":";;AAOA,MAAMA;IACF,YACYC,aAAoD,EACpDC,OAAwC,CAClD;aAFUD,aAAa,GAAbA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,MAA6B,EAAE;QACzC,MAAMC,QAAQ,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QAEzC,MAAME,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAACF,OAAO,KAAK,CAAC,OAAO;QACzDE,MAAM,QAAQ,CAAC;YAACD;SAAM;QAEtB,OAAOA;IACX;AACJ;AAEO,MAAME,oDAA2BC,yBAAAA,oBAA0C,CAAC;IAC/E,gBAAgBP;IAChB,cAAc;QAACQ;QAA6BC;KAAsB;AACtE"}

package/features/contentEntry/unpublishEntry/UnpublishEntryUseCase.d.ts

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

package/features/contentEntry/unpublishEntry/UnpublishEntryUseCase.js

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

package/features/contentEntry/unpublishEntry/UnpublishEntryUseCase.js.map

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

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

@@ -0,0 +1,26 @@
+import type { CmsContentEntry, CmsModel } from "../../../types.js";
+export interface IUnpublishEntryParams {
+    model: CmsModel;
+    revisionId: string;
+}
+export interface IUnpublishEntryGateway {
+    execute(params: IUnpublishEntryParams): Promise<CmsContentEntry>;
+}
+export declare const UnpublishEntryGateway: import("@webiny/di").Abstraction<IUnpublishEntryGateway>;
+export declare namespace UnpublishEntryGateway {
+    type Interface = IUnpublishEntryGateway;
+}
+export interface IUnpublishEntryRepository {
+    execute(params: IUnpublishEntryParams): Promise<CmsContentEntry>;
+}
+export declare const UnpublishEntryRepository: import("@webiny/di").Abstraction<IUnpublishEntryRepository>;
+export declare namespace UnpublishEntryRepository {
+    type Interface = IUnpublishEntryRepository;
+}
+export interface IUnpublishEntryUseCase {
+    execute(params: IUnpublishEntryParams): Promise<CmsContentEntry>;
+}
+export declare const UnpublishEntryUseCase: import("@webiny/di").Abstraction<IUnpublishEntryUseCase>;
+export declare namespace UnpublishEntryUseCase {
+    type Interface = IUnpublishEntryUseCase;
+}

package/features/contentEntry/unpublishEntry/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/unpublishEntry/abstractions.js","sources":["../../../../src/features/contentEntry/unpublishEntry/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { CmsContentEntry, CmsModel } from \"~/types.js\";\n\nexport interface IUnpublishEntryParams {\n    model: CmsModel;\n    revisionId: string;\n}\n\nexport interface IUnpublishEntryGateway {\n    execute(params: IUnpublishEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const UnpublishEntryGateway =\n    createAbstraction<IUnpublishEntryGateway>(\"UnpublishEntryGateway\");\n\nexport namespace UnpublishEntryGateway {\n    export type Interface = IUnpublishEntryGateway;\n}\n\nexport interface IUnpublishEntryRepository {\n    execute(params: IUnpublishEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const UnpublishEntryRepository = createAbstraction<IUnpublishEntryRepository>(\n    \"UnpublishEntryRepository\"\n);\n\nexport namespace UnpublishEntryRepository {\n    export type Interface = IUnpublishEntryRepository;\n}\n\nexport interface IUnpublishEntryUseCase {\n    execute(params: IUnpublishEntryParams): Promise<CmsContentEntry>;\n}\n\nexport const UnpublishEntryUseCase =\n    createAbstraction<IUnpublishEntryUseCase>(\"UnpublishEntryUseCase\");\n\nexport namespace UnpublishEntryUseCase {\n    export type Interface = IUnpublishEntryUseCase;\n}\n"],"names":["UnpublishEntryGateway","createAbstraction","UnpublishEntryRepository","UnpublishEntryUseCase"],"mappings":";AAYO,MAAMA,wBACTC,kBAA0C;AAUvC,MAAMC,2BAA2BD,kBACpC;AAWG,MAAME,wBACTF,kBAA0C"}

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

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

package/features/contentEntry/unpublishEntry/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { UnpublishEntryUseCase } from "./abstractions.js";
+import { UnpublishEntryUseCase as external_UnpublishEntryUseCase_js_UnpublishEntryUseCase } from "./UnpublishEntryUseCase.js";
+import { UnpublishEntryRepository } from "./UnpublishEntryRepository.js";
+import { UnpublishEntryGateway } from "./UnpublishEntryGateway.js";
+const UnpublishEntryFeature = createFeature({
+    name: "CmsContentEntry/UnpublishEntry",
+    register (container) {
+        container.register(external_UnpublishEntryUseCase_js_UnpublishEntryUseCase);
+        container.register(UnpublishEntryRepository).inSingletonScope();
+        container.register(UnpublishEntryGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            useCase: container.resolve(UnpublishEntryUseCase)
+        };
+    }
+});
+export { UnpublishEntryFeature };
+
+//# sourceMappingURL=feature.js.map

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

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

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