@webiny/api-headless-cms 0.0.0-unstable.e6f0dc8ca7 → 0.0.0-unstable.e9333b3f0b

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/CreateEntryRevisionFromDataFactory.js

@@ -0,0 +1,180 @@
+import { Result } from "@webiny/feature/api";
+import { CreateEntryRevisionFromDataFactory } from "./abstractions.js";
+import { AccessControl, CmsContext } from "../../../shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { getDate } from "../../../../utils/date.js";
+import { getIdentity } from "../../../../utils/identity.js";
+import { mapAndCleanUpdatedInputData } from "../mapAndCleanUpdatedInputData.js";
+import { validateModelEntryData } from "../../../../crud/contentEntry/entryDataValidation.js";
+import { EntryValidationError } from "../../../../domain/contentEntry/errors.js";
+import { referenceFieldsMapping } from "../../../../crud/contentEntry/referenceFieldsMapping.js";
+import { createIdentifier, parseIdentifier } from "@webiny/utils";
+import error from "@webiny/error";
+import { STATUS_DRAFT, STATUS_PUBLISHED, STATUS_UNPUBLISHED } from "../statuses.js";
+import { NotAuthorizedError } from "../../../../utils/errors.js";
+import { getSystem } from "../system.js";
+import { ModelToAstConverter } from "../../../contentModel/ModelToAstConverter/abstractions.js";
+import { ensureItemIds } from "../../ensureItemIds.js";
+import { hasEntryContentChanged } from "../hasEntryContentChanged.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../GetLatestRevisionByEntryId/index.js";
+const increaseEntryIdVersion = (id)=>{
+    const { id: entryId, version } = parseIdentifier(id);
+    if (!version) throw new error("Cannot increase version on the ID without the version part.", "WRONG_ID", {
+        id
+    });
+    return {
+        entryId,
+        version: version + 1,
+        id: createIdentifier({
+            id: entryId,
+            version: version + 1
+        })
+    };
+};
+class CreateEntryRevisionFromDataFactoryImpl {
+    constructor(cmsContext, identityContext, accessControl, modelToAstConverter, getLatestRevision){
+        this.cmsContext = cmsContext;
+        this.identityContext = identityContext;
+        this.accessControl = accessControl;
+        this.modelToAstConverter = modelToAstConverter;
+        this.getLatestRevision = getLatestRevision;
+    }
+    async create(sourceId, model, rawInput, originalEntry, options) {
+        const latestResult = await this.getLatestRevision.execute(model, {
+            id: originalEntry.entryId
+        });
+        if (latestResult.isFail()) return Result.fail(latestResult.error);
+        const latestStorageEntry = latestResult.value;
+        const initialValues = {
+            ...originalEntry.values,
+            ...mapAndCleanUpdatedInputData(model, rawInput.values)
+        };
+        const modelAst = this.modelToAstConverter.toAst(model);
+        await ensureItemIds(modelAst, initialValues);
+        const invalidFields = await validateModelEntryData({
+            context: this.cmsContext,
+            model,
+            values: initialValues,
+            entry: originalEntry,
+            skipValidation: options?.skipValidation
+        });
+        if (invalidFields.length > 0) return Result.fail(new EntryValidationError("Validation failed.", invalidFields));
+        const values = await referenceFieldsMapping({
+            context: this.cmsContext,
+            model,
+            values: initialValues,
+            validateEntries: false
+        });
+        const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;
+        const { id, version: nextVersion } = increaseEntryIdVersion(latestId);
+        const currentIdentity = this.identityContext.getIdentity();
+        const currentDateTime = new Date();
+        const status = rawInput.status || STATUS_DRAFT;
+        if (status !== STATUS_DRAFT) {
+            if (status === STATUS_PUBLISHED) {
+                const canPublish = await this.accessControl.canAccessEntry({
+                    model,
+                    pw: "p"
+                });
+                if (!canPublish) return Result.fail(new NotAuthorizedError(`Not allowed to access "${model.modelId}" entries.`));
+            } else if (status === STATUS_UNPUBLISHED) {
+                const canUnpublish = await this.accessControl.canAccessEntry({
+                    model,
+                    pw: "u"
+                });
+                if (!canUnpublish) return Result.fail(new NotAuthorizedError(`Not allowed to access "${model.modelId}" entries.`));
+            }
+        }
+        const locked = status !== STATUS_DRAFT;
+        let revisionLevelPublishingMetaFields = {
+            revisionFirstPublishedOn: getDate(rawInput.revisionFirstPublishedOn, null),
+            revisionLastPublishedOn: getDate(rawInput.revisionLastPublishedOn, null),
+            revisionFirstPublishedBy: getIdentity(rawInput.revisionFirstPublishedBy, null),
+            revisionLastPublishedBy: getIdentity(rawInput.revisionLastPublishedBy, null)
+        };
+        let entryLevelPublishingMetaFields = {
+            firstPublishedOn: getDate(rawInput.firstPublishedOn, latestStorageEntry.firstPublishedOn),
+            lastPublishedOn: getDate(rawInput.lastPublishedOn, latestStorageEntry.lastPublishedOn),
+            firstPublishedBy: getIdentity(rawInput.firstPublishedBy, latestStorageEntry.firstPublishedBy),
+            lastPublishedBy: getIdentity(rawInput.lastPublishedBy, latestStorageEntry.lastPublishedBy)
+        };
+        if (status === STATUS_PUBLISHED) {
+            revisionLevelPublishingMetaFields = {
+                revisionFirstPublishedOn: getDate(rawInput.revisionFirstPublishedOn, currentDateTime),
+                revisionLastPublishedOn: getDate(rawInput.revisionLastPublishedOn, currentDateTime),
+                revisionFirstPublishedBy: getIdentity(rawInput.revisionFirstPublishedBy, currentIdentity),
+                revisionLastPublishedBy: getIdentity(rawInput.revisionLastPublishedBy, currentIdentity)
+            };
+            entryLevelPublishingMetaFields = {
+                firstPublishedOn: getDate(rawInput.firstPublishedOn, latestStorageEntry.firstPublishedOn),
+                lastPublishedOn: getDate(rawInput.lastPublishedOn, currentDateTime),
+                firstPublishedBy: getIdentity(rawInput.firstPublishedBy, latestStorageEntry.firstPublishedBy),
+                lastPublishedBy: getIdentity(rawInput.lastPublishedBy, currentIdentity)
+            };
+        }
+        const contentChanged = hasEntryContentChanged({
+            values,
+            baselineValues: latestStorageEntry.values
+        });
+        const entryLevelSaved = contentChanged ? {
+            savedOn: currentDateTime,
+            modifiedOn: currentDateTime,
+            savedBy: currentIdentity,
+            modifiedBy: currentIdentity
+        } : {
+            savedOn: latestStorageEntry.savedOn,
+            modifiedOn: latestStorageEntry.modifiedOn,
+            savedBy: latestStorageEntry.savedBy,
+            modifiedBy: latestStorageEntry.modifiedBy
+        };
+        const entry = {
+            ...originalEntry,
+            id,
+            version: nextVersion,
+            createdOn: getDate(rawInput.createdOn, latestStorageEntry.createdOn),
+            savedOn: getDate(rawInput.savedOn, entryLevelSaved.savedOn),
+            modifiedOn: getDate(rawInput.modifiedOn, entryLevelSaved.modifiedOn),
+            createdBy: getIdentity(rawInput.createdBy, latestStorageEntry.createdBy),
+            savedBy: getIdentity(rawInput.savedBy, entryLevelSaved.savedBy),
+            modifiedBy: getIdentity(rawInput.modifiedBy, entryLevelSaved.modifiedBy),
+            ...entryLevelPublishingMetaFields,
+            revisionCreatedOn: getDate(rawInput.revisionCreatedOn, currentDateTime),
+            revisionSavedOn: getDate(rawInput.revisionSavedOn, currentDateTime),
+            revisionModifiedOn: getDate(rawInput.revisionModifiedOn, null),
+            revisionCreatedBy: getIdentity(rawInput.revisionCreatedBy, currentIdentity),
+            revisionSavedBy: getIdentity(rawInput.revisionSavedBy, currentIdentity),
+            revisionModifiedBy: getIdentity(rawInput.revisionModifiedBy, null),
+            revisionDescription: void 0,
+            ...revisionLevelPublishingMetaFields,
+            locked,
+            status,
+            values,
+            system: getSystem({
+                input: rawInput,
+                original: originalEntry
+            }),
+            live: originalEntry.live,
+            expiresAt: null
+        };
+        return Result.ok({
+            entry,
+            input: {
+                ...rawInput,
+                values: structuredClone(values)
+            }
+        });
+    }
+}
+const CreateEntryRevisionFromDataFactory_CreateEntryRevisionFromDataFactory = CreateEntryRevisionFromDataFactory.createImplementation({
+    implementation: CreateEntryRevisionFromDataFactoryImpl,
+    dependencies: [
+        CmsContext,
+        IdentityContext,
+        AccessControl,
+        ModelToAstConverter,
+        GetLatestRevisionByEntryIdUseCase
+    ]
+});
+export { CreateEntryRevisionFromDataFactory_CreateEntryRevisionFromDataFactory as CreateEntryRevisionFromDataFactory };
+
+//# sourceMappingURL=CreateEntryRevisionFromDataFactory.js.map

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/CreateEntryRevisionFromDataFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/CreateEntryRevisionFromDataFactory.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/CreateEntryRevisionFromDataFactory.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateEntryRevisionFromDataFactory as FactoryAbstraction,\n    type ICreateEntryRevisionFromDataFactory\n} from \"./abstractions.js\";\nimport { AccessControl, CmsContext } from \"~/features/shared/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    CreateCmsEntryInput,\n    CreateCmsEntryOptionsInput\n} from \"~/types/index.js\";\nimport { getDate } from \"~/utils/date.js\";\nimport { getIdentity } from \"~/utils/identity.js\";\nimport { mapAndCleanUpdatedInputData } from \"../mapAndCleanUpdatedInputData.js\";\nimport { validateModelEntryData } from \"~/crud/contentEntry/entryDataValidation.js\";\nimport { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport { referenceFieldsMapping } from \"~/crud/contentEntry/referenceFieldsMapping.js\";\nimport { createIdentifier, parseIdentifier } from \"@webiny/utils\";\nimport WebinyError from \"@webiny/error\";\nimport { STATUS_DRAFT, STATUS_PUBLISHED, STATUS_UNPUBLISHED } from \"../statuses.js\";\nimport { NotAuthorizedError } from \"~/utils/errors.js\";\nimport { getSystem } from \"../system.js\";\nimport { ModelToAstConverter } from \"~/features/contentModel/ModelToAstConverter/abstractions.js\";\nimport { ensureItemIds } from \"../../ensureItemIds.js\";\nimport { hasEntryContentChanged } from \"../hasEntryContentChanged.js\";\nimport { GetLatestRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\n\nconst increaseEntryIdVersion = (id: string) => {\n    const { id: entryId, version } = parseIdentifier(id);\n    if (!version) {\n        throw new WebinyError(\n            \"Cannot increase version on the ID without the version part.\",\n            \"WRONG_ID\",\n            {\n                id\n            }\n        );\n    }\n    return {\n        entryId,\n        version: version + 1,\n        id: createIdentifier({\n            id: entryId,\n            version: version + 1\n        })\n    };\n};\n\nclass CreateEntryRevisionFromDataFactoryImpl implements ICreateEntryRevisionFromDataFactory {\n    public constructor(\n        private readonly cmsContext: CmsContext.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly accessControl: AccessControl.Interface,\n        private readonly modelToAstConverter: ModelToAstConverter.Interface,\n        private readonly getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface\n    ) {}\n\n    public async create<TValues extends CmsEntryValues = CmsEntryValues>(\n        sourceId: string,\n        model: CmsModel,\n        rawInput: CreateCmsEntryInput<TValues>,\n        originalEntry: CmsEntry<TValues>,\n        options?: CreateCmsEntryOptionsInput\n    ): Promise<FactoryAbstraction.Return<TValues>> {\n        const latestResult = await this.getLatestRevision.execute<TValues>(model, {\n            id: originalEntry.entryId\n        });\n        if (latestResult.isFail()) {\n            return Result.fail(latestResult.error);\n        }\n        const latestStorageEntry = latestResult.value;\n\n        const initialValues = {\n            ...originalEntry.values,\n            ...mapAndCleanUpdatedInputData<TValues>(model, rawInput.values)\n        };\n\n        const modelAst = this.modelToAstConverter.toAst(model);\n        await ensureItemIds(modelAst, initialValues);\n\n        const invalidFields = await validateModelEntryData({\n            context: this.cmsContext,\n            model,\n            values: initialValues,\n            entry: originalEntry,\n            skipValidation: options?.skipValidation\n        });\n        if (invalidFields.length > 0) {\n            return Result.fail(new EntryValidationError(\"Validation failed.\", invalidFields));\n        }\n\n        const values = await referenceFieldsMapping<TValues>({\n            context: this.cmsContext,\n            model,\n            values: initialValues,\n            validateEntries: false\n        });\n\n        const latestId = latestStorageEntry ? latestStorageEntry.id : sourceId;\n        const { id, version: nextVersion } = increaseEntryIdVersion(latestId);\n\n        const currentIdentity = this.identityContext.getIdentity();\n        const currentDateTime = new Date();\n\n        const status = rawInput.status || STATUS_DRAFT;\n        if (status !== STATUS_DRAFT) {\n            if (status === STATUS_PUBLISHED) {\n                const canPublish = await this.accessControl.canAccessEntry({ model, pw: \"p\" });\n                if (!canPublish) {\n                    return Result.fail(\n                        new NotAuthorizedError(`Not allowed to access \"${model.modelId}\" entries.`)\n                    );\n                }\n            } else if (status === STATUS_UNPUBLISHED) {\n                const canUnpublish = await this.accessControl.canAccessEntry({ model, pw: \"u\" });\n                if (!canUnpublish) {\n                    return Result.fail(\n                        new NotAuthorizedError(`Not allowed to access \"${model.modelId}\" entries.`)\n                    );\n                }\n            }\n        }\n\n        const locked = status !== STATUS_DRAFT;\n\n        let revisionLevelPublishingMetaFields: Pick<\n            CmsEntry,\n            | \"revisionFirstPublishedOn\"\n            | \"revisionLastPublishedOn\"\n            | \"revisionFirstPublishedBy\"\n            | \"revisionLastPublishedBy\"\n        > = {\n            revisionFirstPublishedOn: getDate(rawInput.revisionFirstPublishedOn, null),\n            revisionLastPublishedOn: getDate(rawInput.revisionLastPublishedOn, null),\n            revisionFirstPublishedBy: getIdentity(rawInput.revisionFirstPublishedBy, null),\n            revisionLastPublishedBy: getIdentity(rawInput.revisionLastPublishedBy, null)\n        };\n\n        let entryLevelPublishingMetaFields: Pick<\n            CmsEntry,\n            \"firstPublishedOn\" | \"lastPublishedOn\" | \"firstPublishedBy\" | \"lastPublishedBy\"\n        > = {\n            firstPublishedOn: getDate(\n                rawInput.firstPublishedOn,\n                latestStorageEntry.firstPublishedOn\n            ),\n            lastPublishedOn: getDate(rawInput.lastPublishedOn, latestStorageEntry.lastPublishedOn),\n            firstPublishedBy: getIdentity(\n                rawInput.firstPublishedBy,\n                latestStorageEntry.firstPublishedBy\n            ),\n            lastPublishedBy: getIdentity(\n                rawInput.lastPublishedBy,\n                latestStorageEntry.lastPublishedBy\n            )\n        };\n\n        if (status === STATUS_PUBLISHED) {\n            revisionLevelPublishingMetaFields = {\n                revisionFirstPublishedOn: getDate(\n                    rawInput.revisionFirstPublishedOn,\n                    currentDateTime\n                ),\n                revisionLastPublishedOn: getDate(rawInput.revisionLastPublishedOn, currentDateTime),\n                revisionFirstPublishedBy: getIdentity(\n                    rawInput.revisionFirstPublishedBy,\n                    currentIdentity\n                ),\n                revisionLastPublishedBy: getIdentity(\n                    rawInput.revisionLastPublishedBy,\n                    currentIdentity\n                )\n            };\n\n            entryLevelPublishingMetaFields = {\n                firstPublishedOn: getDate(\n                    rawInput.firstPublishedOn,\n                    latestStorageEntry.firstPublishedOn\n                ),\n                lastPublishedOn: getDate(rawInput.lastPublishedOn, currentDateTime),\n                firstPublishedBy: getIdentity(\n                    rawInput.firstPublishedBy,\n                    latestStorageEntry.firstPublishedBy\n                ),\n                lastPublishedBy: getIdentity(rawInput.lastPublishedBy, currentIdentity)\n            };\n        }\n\n        /**\n         * Creating a revision without changing the entry's content (e.g. \"New revision\" in the\n         * revisions list, or saving a published entry without editing anything) is not a\n         * modification, so the entry-level saved/modified meta fields are kept. The new revision\n         * is compared with the latest revision, not the source revision: creating a revision from\n         * an older one reverts the content, which is a change. Explicitly provided meta field\n         * values always take precedence.\n         */\n        const contentChanged = hasEntryContentChanged({\n            values,\n            baselineValues: latestStorageEntry.values\n        });\n\n        const entryLevelSaved = contentChanged\n            ? {\n                  savedOn: currentDateTime,\n                  modifiedOn: currentDateTime,\n                  savedBy: currentIdentity,\n                  modifiedBy: currentIdentity\n              }\n            : {\n                  savedOn: latestStorageEntry.savedOn,\n                  modifiedOn: latestStorageEntry.modifiedOn,\n                  savedBy: latestStorageEntry.savedBy,\n                  modifiedBy: latestStorageEntry.modifiedBy\n              };\n\n        const entry: CmsEntry<TValues> = {\n            ...originalEntry,\n            id,\n            version: nextVersion,\n            createdOn: getDate(rawInput.createdOn, latestStorageEntry.createdOn),\n            savedOn: getDate(rawInput.savedOn, entryLevelSaved.savedOn),\n            modifiedOn: getDate(rawInput.modifiedOn, entryLevelSaved.modifiedOn),\n            createdBy: getIdentity(rawInput.createdBy, latestStorageEntry.createdBy)!,\n            savedBy: getIdentity(rawInput.savedBy, entryLevelSaved.savedBy)!,\n            modifiedBy: getIdentity(rawInput.modifiedBy, entryLevelSaved.modifiedBy),\n            ...entryLevelPublishingMetaFields,\n            revisionCreatedOn: getDate(rawInput.revisionCreatedOn, currentDateTime),\n            revisionSavedOn: getDate(rawInput.revisionSavedOn, currentDateTime),\n            revisionModifiedOn: getDate(rawInput.revisionModifiedOn, null),\n            revisionCreatedBy: getIdentity(rawInput.revisionCreatedBy, currentIdentity)!,\n            revisionSavedBy: getIdentity(rawInput.revisionSavedBy, currentIdentity)!,\n            revisionModifiedBy: getIdentity(rawInput.revisionModifiedBy, null),\n            revisionDescription: undefined,\n            ...revisionLevelPublishingMetaFields,\n            locked,\n            status,\n            values,\n            system: getSystem({\n                input: rawInput,\n                original: originalEntry\n            }),\n            live: originalEntry.live,\n            expiresAt: null\n        };\n\n        return Result.ok({\n            entry,\n            input: {\n                ...rawInput,\n                values: structuredClone(values)\n            }\n        });\n    }\n}\n\nexport const CreateEntryRevisionFromDataFactory = FactoryAbstraction.createImplementation({\n    implementation: CreateEntryRevisionFromDataFactoryImpl,\n    dependencies: [\n        CmsContext,\n        IdentityContext,\n        AccessControl,\n        ModelToAstConverter,\n        GetLatestRevisionByEntryIdUseCase\n    ]\n});\n"],"names":["increaseEntryIdVersion","id","entryId","version","parseIdentifier","WebinyError","createIdentifier","CreateEntryRevisionFromDataFactoryImpl","cmsContext","identityContext","accessControl","modelToAstConverter","getLatestRevision","sourceId","model","rawInput","originalEntry","options","latestResult","Result","latestStorageEntry","initialValues","mapAndCleanUpdatedInputData","modelAst","ensureItemIds","invalidFields","validateModelEntryData","EntryValidationError","values","referenceFieldsMapping","latestId","nextVersion","currentIdentity","currentDateTime","Date","status","STATUS_DRAFT","STATUS_PUBLISHED","canPublish","NotAuthorizedError","STATUS_UNPUBLISHED","canUnpublish","locked","revisionLevelPublishingMetaFields","getDate","getIdentity","entryLevelPublishingMetaFields","contentChanged","hasEntryContentChanged","entryLevelSaved","entry","undefined","getSystem","structuredClone","CreateEntryRevisionFromDataFactory","FactoryAbstraction","CmsContext","IdentityContext","AccessControl","ModelToAstConverter","GetLatestRevisionByEntryIdUseCase"],"mappings":";;;;;;;;;;;;;;;;;;;AA8BA,MAAMA,yBAAyB,CAACC;IAC5B,MAAM,EAAE,IAAIC,OAAO,EAAEC,OAAO,EAAE,GAAGC,gBAAgBH;IACjD,IAAI,CAACE,SACD,MAAM,IAAIE,MACN,+DACA,YACA;QACIJ;IACJ;IAGR,OAAO;QACHC;QACA,SAASC,UAAU;QACnB,IAAIG,iBAAiB;YACjB,IAAIJ;YACJ,SAASC,UAAU;QACvB;IACJ;AACJ;AAEA,MAAMI;IACF,YACqBC,UAAgC,EAChCC,eAA0C,EAC1CC,aAAsC,EACtCC,mBAAkD,EAClDC,iBAA8D,CACjF;aALmBJ,UAAU,GAAVA;aACAC,eAAe,GAAfA;aACAC,aAAa,GAAbA;aACAC,mBAAmB,GAAnBA;aACAC,iBAAiB,GAAjBA;IAClB;IAEH,MAAa,OACTC,QAAgB,EAChBC,KAAe,EACfC,QAAsC,EACtCC,aAAgC,EAChCC,OAAoC,EACO;QAC3C,MAAMC,eAAe,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAUJ,OAAO;YACtE,IAAIE,cAAc,OAAO;QAC7B;QACA,IAAIE,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAACD,aAAa,KAAK;QAEzC,MAAME,qBAAqBF,aAAa,KAAK;QAE7C,MAAMG,gBAAgB;YAClB,GAAGL,cAAc,MAAM;YACvB,GAAGM,4BAAqCR,OAAOC,SAAS,MAAM,CAAC;QACnE;QAEA,MAAMQ,WAAW,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAACT;QAChD,MAAMU,cAAcD,UAAUF;QAE9B,MAAMI,gBAAgB,MAAMC,uBAAuB;YAC/C,SAAS,IAAI,CAAC,UAAU;YACxBZ;YACA,QAAQO;YACR,OAAOL;YACP,gBAAgBC,SAAS;QAC7B;QACA,IAAIQ,cAAc,MAAM,GAAG,GACvB,OAAON,OAAO,IAAI,CAAC,IAAIQ,qBAAqB,sBAAsBF;QAGtE,MAAMG,SAAS,MAAMC,uBAAgC;YACjD,SAAS,IAAI,CAAC,UAAU;YACxBf;YACA,QAAQO;YACR,iBAAiB;QACrB;QAEA,MAAMS,WAAWV,qBAAqBA,mBAAmB,EAAE,GAAGP;QAC9D,MAAM,EAAEZ,EAAE,EAAE,SAAS8B,WAAW,EAAE,GAAG/B,uBAAuB8B;QAE5D,MAAME,kBAAkB,IAAI,CAAC,eAAe,CAAC,WAAW;QACxD,MAAMC,kBAAkB,IAAIC;QAE5B,MAAMC,SAASpB,SAAS,MAAM,IAAIqB;QAClC,IAAID,WAAWC,cACX;YAAA,IAAID,WAAWE,kBAAkB;gBAC7B,MAAMC,aAAa,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;oBAAExB;oBAAO,IAAI;gBAAI;gBAC5E,IAAI,CAACwB,YACD,OAAOnB,OAAO,IAAI,CACd,IAAIoB,mBAAmB,CAAC,uBAAuB,EAAEzB,MAAM,OAAO,CAAC,UAAU,CAAC;YAGtF,OAAO,IAAIqB,WAAWK,oBAAoB;gBACtC,MAAMC,eAAe,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;oBAAE3B;oBAAO,IAAI;gBAAI;gBAC9E,IAAI,CAAC2B,cACD,OAAOtB,OAAO,IAAI,CACd,IAAIoB,mBAAmB,CAAC,uBAAuB,EAAEzB,MAAM,OAAO,CAAC,UAAU,CAAC;YAGtF;QAAA;QAGJ,MAAM4B,SAASP,WAAWC;QAE1B,IAAIO,oCAMA;YACA,0BAA0BC,QAAQ7B,SAAS,wBAAwB,EAAE;YACrE,yBAAyB6B,QAAQ7B,SAAS,uBAAuB,EAAE;YACnE,0BAA0B8B,YAAY9B,SAAS,wBAAwB,EAAE;YACzE,yBAAyB8B,YAAY9B,SAAS,uBAAuB,EAAE;QAC3E;QAEA,IAAI+B,iCAGA;YACA,kBAAkBF,QACd7B,SAAS,gBAAgB,EACzBK,mBAAmB,gBAAgB;YAEvC,iBAAiBwB,QAAQ7B,SAAS,eAAe,EAAEK,mBAAmB,eAAe;YACrF,kBAAkByB,YACd9B,SAAS,gBAAgB,EACzBK,mBAAmB,gBAAgB;YAEvC,iBAAiByB,YACb9B,SAAS,eAAe,EACxBK,mBAAmB,eAAe;QAE1C;QAEA,IAAIe,WAAWE,kBAAkB;YAC7BM,oCAAoC;gBAChC,0BAA0BC,QACtB7B,SAAS,wBAAwB,EACjCkB;gBAEJ,yBAAyBW,QAAQ7B,SAAS,uBAAuB,EAAEkB;gBACnE,0BAA0BY,YACtB9B,SAAS,wBAAwB,EACjCiB;gBAEJ,yBAAyBa,YACrB9B,SAAS,uBAAuB,EAChCiB;YAER;YAEAc,iCAAiC;gBAC7B,kBAAkBF,QACd7B,SAAS,gBAAgB,EACzBK,mBAAmB,gBAAgB;gBAEvC,iBAAiBwB,QAAQ7B,SAAS,eAAe,EAAEkB;gBACnD,kBAAkBY,YACd9B,SAAS,gBAAgB,EACzBK,mBAAmB,gBAAgB;gBAEvC,iBAAiByB,YAAY9B,SAAS,eAAe,EAAEiB;YAC3D;QACJ;QAUA,MAAMe,iBAAiBC,uBAAuB;YAC1CpB;YACA,gBAAgBR,mBAAmB,MAAM;QAC7C;QAEA,MAAM6B,kBAAkBF,iBAClB;YACI,SAASd;YACT,YAAYA;YACZ,SAASD;YACT,YAAYA;QAChB,IACA;YACI,SAASZ,mBAAmB,OAAO;YACnC,YAAYA,mBAAmB,UAAU;YACzC,SAASA,mBAAmB,OAAO;YACnC,YAAYA,mBAAmB,UAAU;QAC7C;QAEN,MAAM8B,QAA2B;YAC7B,GAAGlC,aAAa;YAChBf;YACA,SAAS8B;YACT,WAAWa,QAAQ7B,SAAS,SAAS,EAAEK,mBAAmB,SAAS;YACnE,SAASwB,QAAQ7B,SAAS,OAAO,EAAEkC,gBAAgB,OAAO;YAC1D,YAAYL,QAAQ7B,SAAS,UAAU,EAAEkC,gBAAgB,UAAU;YACnE,WAAWJ,YAAY9B,SAAS,SAAS,EAAEK,mBAAmB,SAAS;YACvE,SAASyB,YAAY9B,SAAS,OAAO,EAAEkC,gBAAgB,OAAO;YAC9D,YAAYJ,YAAY9B,SAAS,UAAU,EAAEkC,gBAAgB,UAAU;YACvE,GAAGH,8BAA8B;YACjC,mBAAmBF,QAAQ7B,SAAS,iBAAiB,EAAEkB;YACvD,iBAAiBW,QAAQ7B,SAAS,eAAe,EAAEkB;YACnD,oBAAoBW,QAAQ7B,SAAS,kBAAkB,EAAE;YACzD,mBAAmB8B,YAAY9B,SAAS,iBAAiB,EAAEiB;YAC3D,iBAAiBa,YAAY9B,SAAS,eAAe,EAAEiB;YACvD,oBAAoBa,YAAY9B,SAAS,kBAAkB,EAAE;YAC7D,qBAAqBoC;YACrB,GAAGR,iCAAiC;YACpCD;YACAP;YACAP;YACA,QAAQwB,UAAU;gBACd,OAAOrC;gBACP,UAAUC;YACd;YACA,MAAMA,cAAc,IAAI;YACxB,WAAW;QACf;QAEA,OAAOG,OAAO,EAAE,CAAC;YACb+B;YACA,OAAO;gBACH,GAAGnC,QAAQ;gBACX,QAAQsC,gBAAgBzB;YAC5B;QACJ;IACJ;AACJ;AAEO,MAAM0B,wEAAqCC,mCAAAA,oBAAuC,CAAC;IACtF,gBAAgBhD;IAChB,cAAc;QACViD;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/abstractions.d.ts

@@ -0,0 +1,29 @@
+import { type Result } from "@webiny/feature/api";
+import type { GetLatestRevisionByEntryIdUseCase } from "../../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import type { EntryValidationError } from "../../../../domain/contentEntry/errors.js";
+import type { NotAuthorizedError } from "../../../../utils/errors.js";
+import type { CmsEntry, CmsEntryValues, CmsModel, CreateCmsEntryInput, CreateCmsEntryOptionsInput } from "../../../../types/index.js";
+export interface ICreateEntryRevisionFromDataResponse<TValues extends CmsEntryValues = CmsEntryValues> {
+    entry: CmsEntry<TValues>;
+    input: CreateCmsEntryInput<TValues>;
+}
+/**
+ * Expected failures of building the data of a new entry revision.
+ */
+export interface ICreateEntryRevisionFromDataFactoryErrors {
+    latest: GetLatestRevisionByEntryIdUseCase.Error;
+    validation: EntryValidationError;
+    notAuthorized: NotAuthorizedError;
+}
+type FactoryError = ICreateEntryRevisionFromDataFactoryErrors[keyof ICreateEntryRevisionFromDataFactoryErrors];
+export interface ICreateEntryRevisionFromDataFactory {
+    create<TValues extends CmsEntryValues = CmsEntryValues>(sourceId: string, model: CmsModel, rawInput: CreateCmsEntryInput<TValues>, originalEntry: CmsEntry<TValues>, options?: CreateCmsEntryOptionsInput): Promise<Result<ICreateEntryRevisionFromDataResponse<TValues>, FactoryError>>;
+}
+export declare const CreateEntryRevisionFromDataFactory: import("@webiny/di").Abstraction<ICreateEntryRevisionFromDataFactory>;
+export declare namespace CreateEntryRevisionFromDataFactory {
+    type Interface = ICreateEntryRevisionFromDataFactory;
+    type Error = FactoryError;
+    type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<ICreateEntryRevisionFromDataResponse<TValues>, FactoryError>;
+    type Response<TValues extends CmsEntryValues = CmsEntryValues> = ICreateEntryRevisionFromDataResponse<TValues>;
+}
+export {};

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/abstractions.js

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

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/abstractions.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { GetLatestRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport type { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport type { NotAuthorizedError } from \"~/utils/errors.js\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    CreateCmsEntryInput,\n    CreateCmsEntryOptionsInput\n} from \"~/types/index.js\";\n\nexport interface ICreateEntryRevisionFromDataResponse<\n    TValues extends CmsEntryValues = CmsEntryValues\n> {\n    entry: CmsEntry<TValues>;\n    input: CreateCmsEntryInput<TValues>;\n}\n\n/**\n * Expected failures of building the data of a new entry revision.\n */\nexport interface ICreateEntryRevisionFromDataFactoryErrors {\n    latest: GetLatestRevisionByEntryIdUseCase.Error;\n    validation: EntryValidationError;\n    notAuthorized: NotAuthorizedError;\n}\n\ntype FactoryError =\n    ICreateEntryRevisionFromDataFactoryErrors[keyof ICreateEntryRevisionFromDataFactoryErrors];\n\nexport interface ICreateEntryRevisionFromDataFactory {\n    create<TValues extends CmsEntryValues = CmsEntryValues>(\n        sourceId: string,\n        model: CmsModel,\n        rawInput: CreateCmsEntryInput<TValues>,\n        originalEntry: CmsEntry<TValues>,\n        options?: CreateCmsEntryOptionsInput\n    ): Promise<Result<ICreateEntryRevisionFromDataResponse<TValues>, FactoryError>>;\n}\n\nexport const CreateEntryRevisionFromDataFactory =\n    createAbstraction<ICreateEntryRevisionFromDataFactory>(\n        \"Cms/Entry/CreateEntryRevisionFromDataFactory\"\n    );\n\nexport namespace CreateEntryRevisionFromDataFactory {\n    export type Interface = ICreateEntryRevisionFromDataFactory;\n    export type Error = FactoryError;\n    export type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<\n        ICreateEntryRevisionFromDataResponse<TValues>,\n        FactoryError\n    >;\n    export type Response<TValues extends CmsEntryValues = CmsEntryValues> =\n        ICreateEntryRevisionFromDataResponse<TValues>;\n}\n"],"names":["CreateEntryRevisionFromDataFactory","createAbstraction"],"mappings":";AAyCO,MAAMA,qCACTC,kBACI"}

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/feature.d.ts

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

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/feature.js

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

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/feature.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateEntryRevisionFromDataFactory } from \"./CreateEntryRevisionFromDataFactory.js\";\n\nexport const CreateEntryRevisionFromDataFactoryFeature = createFeature({\n    name: \"CreateEntryRevisionFromDataFactory\",\n    register(container) {\n        container.register(CreateEntryRevisionFromDataFactory).inSingletonScope();\n    }\n});\n"],"names":["CreateEntryRevisionFromDataFactoryFeature","createFeature","container","CreateEntryRevisionFromDataFactory"],"mappings":";;AAGO,MAAMA,4CAA4CC,cAAc;IACnE,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,oCAAoC,gBAAgB;IAC3E;AACJ"}

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/index.d.ts

@@ -0,0 +1,2 @@
+export { CreateEntryRevisionFromDataFactory } from "./abstractions.js";
+export { CreateEntryRevisionFromDataFactoryFeature } from "./feature.js";

package/features/contentEntry/entryDataFactories/CreateEntryRevisionFromDataFactory/index.js

@@ -0,0 +1,2 @@
+export { CreateEntryRevisionFromDataFactory } from "./abstractions.js";
+export { CreateEntryRevisionFromDataFactoryFeature } from "./feature.js";

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/CreatePublishEntryDataFactory.d.ts

@@ -0,0 +1,16 @@
+import { CreatePublishEntryDataFactory as FactoryAbstraction, type ICreatePublishEntryDataFactory } from "./abstractions.js";
+import { CmsContext } from "../../../../features/shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../../types/index.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+declare class CreatePublishEntryDataFactoryImpl implements ICreatePublishEntryDataFactory {
+    private readonly cmsContext;
+    private readonly identityContext;
+    private readonly getLatestRevision;
+    constructor(cmsContext: CmsContext.Interface, identityContext: IdentityContext.Interface, getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface);
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, originalEntry: CmsEntry<TValues>): Promise<FactoryAbstraction.Return<TValues>>;
+}
+export declare const CreatePublishEntryDataFactory: typeof CreatePublishEntryDataFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ICreatePublishEntryDataFactory>;
+};
+export {};

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/CreatePublishEntryDataFactory.js

@@ -0,0 +1,71 @@
+import { Result } from "@webiny/feature/api";
+import { CreatePublishEntryDataFactory } from "./abstractions.js";
+import { CmsContext } from "../../../shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { STATUS_PUBLISHED } from "../statuses.js";
+import { validateModelEntryData } from "../../../../crud/contentEntry/entryDataValidation.js";
+import { EntryValidationError } from "../../../../domain/contentEntry/errors.js";
+import { getIdentity } from "../../../../utils/identity.js";
+import { getDate } from "../../../../utils/date.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../GetLatestRevisionByEntryId/index.js";
+class CreatePublishEntryDataFactoryImpl {
+    constructor(cmsContext, identityContext, getLatestRevision){
+        this.cmsContext = cmsContext;
+        this.identityContext = identityContext;
+        this.getLatestRevision = getLatestRevision;
+    }
+    async create(model, originalEntry) {
+        const latestResult = await this.getLatestRevision.execute(model, {
+            id: originalEntry.entryId
+        });
+        if (latestResult.isFail()) return Result.fail(latestResult.error);
+        const latestEntry = latestResult.value;
+        const invalidFields = await validateModelEntryData({
+            context: this.cmsContext,
+            model,
+            values: originalEntry.values,
+            entry: originalEntry
+        });
+        if (invalidFields.length > 0) return Result.fail(new EntryValidationError("Validation failed.", invalidFields));
+        const currentDateTime = new Date().toISOString();
+        const currentIdentity = this.identityContext.getIdentity();
+        const entry = {
+            ...originalEntry,
+            status: STATUS_PUBLISHED,
+            locked: true,
+            createdOn: getDate(latestEntry.createdOn),
+            modifiedOn: getDate(latestEntry.modifiedOn),
+            savedOn: getDate(latestEntry.savedOn, originalEntry.savedOn),
+            firstPublishedOn: getDate(latestEntry.firstPublishedOn, currentDateTime),
+            lastPublishedOn: getDate(currentDateTime),
+            createdBy: getIdentity(latestEntry.createdBy),
+            modifiedBy: getIdentity(latestEntry.modifiedBy),
+            savedBy: getIdentity(latestEntry.savedBy, originalEntry.savedBy),
+            firstPublishedBy: getIdentity(latestEntry.firstPublishedBy, currentIdentity),
+            lastPublishedBy: getIdentity(currentIdentity),
+            revisionCreatedOn: getDate(originalEntry.revisionCreatedOn),
+            revisionFirstPublishedOn: getDate(originalEntry.revisionFirstPublishedOn, currentDateTime),
+            revisionLastPublishedOn: getDate(currentDateTime),
+            revisionCreatedBy: getIdentity(originalEntry.revisionCreatedBy),
+            revisionFirstPublishedBy: getIdentity(originalEntry.revisionFirstPublishedBy, currentIdentity),
+            revisionLastPublishedBy: getIdentity(currentIdentity),
+            live: {
+                version: originalEntry.version
+            }
+        };
+        return Result.ok({
+            entry
+        });
+    }
+}
+const CreatePublishEntryDataFactory_CreatePublishEntryDataFactory = CreatePublishEntryDataFactory.createImplementation({
+    implementation: CreatePublishEntryDataFactoryImpl,
+    dependencies: [
+        CmsContext,
+        IdentityContext,
+        GetLatestRevisionByEntryIdUseCase
+    ]
+});
+export { CreatePublishEntryDataFactory_CreatePublishEntryDataFactory as CreatePublishEntryDataFactory };
+
+//# sourceMappingURL=CreatePublishEntryDataFactory.js.map

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/CreatePublishEntryDataFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/CreatePublishEntryDataFactory.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/CreatePublishEntryDataFactory.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreatePublishEntryDataFactory as FactoryAbstraction,\n    type ICreatePublishEntryDataFactory\n} from \"./abstractions.js\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { STATUS_PUBLISHED } from \"../statuses.js\";\nimport { validateModelEntryData } from \"~/crud/contentEntry/entryDataValidation.js\";\nimport { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport { getIdentity } from \"~/utils/identity.js\";\nimport { getDate } from \"~/utils/date.js\";\nimport { GetLatestRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\n\nclass CreatePublishEntryDataFactoryImpl implements ICreatePublishEntryDataFactory {\n    public constructor(\n        private readonly cmsContext: CmsContext.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface\n    ) {}\n\n    public async create<TValues extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        originalEntry: CmsEntry<TValues>\n    ): Promise<FactoryAbstraction.Return<TValues>> {\n        const latestResult = await this.getLatestRevision.execute<TValues>(model, {\n            id: originalEntry.entryId\n        });\n        if (latestResult.isFail()) {\n            return Result.fail(latestResult.error);\n        }\n        const latestEntry = latestResult.value;\n\n        const invalidFields = await validateModelEntryData({\n            context: this.cmsContext,\n            model,\n            values: originalEntry.values,\n            entry: originalEntry\n        });\n        if (invalidFields.length > 0) {\n            return Result.fail(new EntryValidationError(\"Validation failed.\", invalidFields));\n        }\n\n        const currentDateTime = new Date().toISOString();\n        const currentIdentity = this.identityContext.getIdentity();\n\n        /**\n         * Publishing is not a content modification, so saved/modified meta fields are kept.\n         * Entry-level values are taken from the latest revision, because storage copies them\n         * onto the latest revision when a non-latest revision is published. Revision-level\n         * values are the published revision's own, and come from `originalEntry`.\n         */\n        const entry: CmsEntry<TValues> = {\n            ...originalEntry,\n            status: STATUS_PUBLISHED,\n            locked: true,\n            createdOn: getDate(latestEntry.createdOn),\n            modifiedOn: getDate(latestEntry.modifiedOn),\n            savedOn: getDate(latestEntry.savedOn, originalEntry.savedOn),\n            firstPublishedOn: getDate(latestEntry.firstPublishedOn, currentDateTime),\n            lastPublishedOn: getDate(currentDateTime),\n            createdBy: getIdentity(latestEntry.createdBy),\n            modifiedBy: getIdentity(latestEntry.modifiedBy),\n            savedBy: getIdentity(latestEntry.savedBy, originalEntry.savedBy),\n            firstPublishedBy: getIdentity(latestEntry.firstPublishedBy, currentIdentity),\n            lastPublishedBy: getIdentity(currentIdentity),\n            revisionCreatedOn: getDate(originalEntry.revisionCreatedOn),\n            revisionFirstPublishedOn: getDate(\n                originalEntry.revisionFirstPublishedOn,\n                currentDateTime\n            ),\n            revisionLastPublishedOn: getDate(currentDateTime),\n            revisionCreatedBy: getIdentity(originalEntry.revisionCreatedBy),\n            revisionFirstPublishedBy: getIdentity(\n                originalEntry.revisionFirstPublishedBy,\n                currentIdentity\n            ),\n            revisionLastPublishedBy: getIdentity(currentIdentity),\n            live: {\n                version: originalEntry.version\n            }\n        };\n\n        return Result.ok({ entry });\n    }\n}\n\nexport const CreatePublishEntryDataFactory = FactoryAbstraction.createImplementation({\n    implementation: CreatePublishEntryDataFactoryImpl,\n    dependencies: [CmsContext, IdentityContext, GetLatestRevisionByEntryIdUseCase]\n});\n"],"names":["CreatePublishEntryDataFactoryImpl","cmsContext","identityContext","getLatestRevision","model","originalEntry","latestResult","Result","latestEntry","invalidFields","validateModelEntryData","EntryValidationError","currentDateTime","Date","currentIdentity","entry","STATUS_PUBLISHED","getDate","getIdentity","CreatePublishEntryDataFactory","FactoryAbstraction","CmsContext","IdentityContext","GetLatestRevisionByEntryIdUseCase"],"mappings":";;;;;;;;;;AAeA,MAAMA;IACF,YACqBC,UAAgC,EAChCC,eAA0C,EAC1CC,iBAA8D,CACjF;aAHmBF,UAAU,GAAVA;aACAC,eAAe,GAAfA;aACAC,iBAAiB,GAAjBA;IAClB;IAEH,MAAa,OACTC,KAAe,EACfC,aAAgC,EACW;QAC3C,MAAMC,eAAe,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAUF,OAAO;YACtE,IAAIC,cAAc,OAAO;QAC7B;QACA,IAAIC,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAACD,aAAa,KAAK;QAEzC,MAAME,cAAcF,aAAa,KAAK;QAEtC,MAAMG,gBAAgB,MAAMC,uBAAuB;YAC/C,SAAS,IAAI,CAAC,UAAU;YACxBN;YACA,QAAQC,cAAc,MAAM;YAC5B,OAAOA;QACX;QACA,IAAII,cAAc,MAAM,GAAG,GACvB,OAAOF,OAAO,IAAI,CAAC,IAAII,qBAAqB,sBAAsBF;QAGtE,MAAMG,kBAAkB,IAAIC,OAAO,WAAW;QAC9C,MAAMC,kBAAkB,IAAI,CAAC,eAAe,CAAC,WAAW;QAQxD,MAAMC,QAA2B;YAC7B,GAAGV,aAAa;YAChB,QAAQW;YACR,QAAQ;YACR,WAAWC,QAAQT,YAAY,SAAS;YACxC,YAAYS,QAAQT,YAAY,UAAU;YAC1C,SAASS,QAAQT,YAAY,OAAO,EAAEH,cAAc,OAAO;YAC3D,kBAAkBY,QAAQT,YAAY,gBAAgB,EAAEI;YACxD,iBAAiBK,QAAQL;YACzB,WAAWM,YAAYV,YAAY,SAAS;YAC5C,YAAYU,YAAYV,YAAY,UAAU;YAC9C,SAASU,YAAYV,YAAY,OAAO,EAAEH,cAAc,OAAO;YAC/D,kBAAkBa,YAAYV,YAAY,gBAAgB,EAAEM;YAC5D,iBAAiBI,YAAYJ;YAC7B,mBAAmBG,QAAQZ,cAAc,iBAAiB;YAC1D,0BAA0BY,QACtBZ,cAAc,wBAAwB,EACtCO;YAEJ,yBAAyBK,QAAQL;YACjC,mBAAmBM,YAAYb,cAAc,iBAAiB;YAC9D,0BAA0Ba,YACtBb,cAAc,wBAAwB,EACtCS;YAEJ,yBAAyBI,YAAYJ;YACrC,MAAM;gBACF,SAAST,cAAc,OAAO;YAClC;QACJ;QAEA,OAAOE,OAAO,EAAE,CAAC;YAAEQ;QAAM;IAC7B;AACJ;AAEO,MAAMI,8DAAgCC,8BAAAA,oBAAuC,CAAC;IACjF,gBAAgBpB;IAChB,cAAc;QAACqB;QAAYC;QAAiBC;KAAkC;AAClF"}

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/abstractions.d.ts

@@ -0,0 +1,26 @@
+import { type Result } from "@webiny/feature/api";
+import type { GetLatestRevisionByEntryIdUseCase } from "../../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import type { EntryValidationError } from "../../../../domain/contentEntry/errors.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../../types/index.js";
+export interface ICreatePublishEntryDataResponse<TValues extends CmsEntryValues = CmsEntryValues> {
+    entry: CmsEntry<TValues>;
+}
+/**
+ * Expected failures of building the data of an entry being published.
+ */
+export interface ICreatePublishEntryDataFactoryErrors {
+    latest: GetLatestRevisionByEntryIdUseCase.Error;
+    validation: EntryValidationError;
+}
+type FactoryError = ICreatePublishEntryDataFactoryErrors[keyof ICreatePublishEntryDataFactoryErrors];
+export interface ICreatePublishEntryDataFactory {
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, originalEntry: CmsEntry<TValues>): Promise<Result<ICreatePublishEntryDataResponse<TValues>, FactoryError>>;
+}
+export declare const CreatePublishEntryDataFactory: import("@webiny/di").Abstraction<ICreatePublishEntryDataFactory>;
+export declare namespace CreatePublishEntryDataFactory {
+    type Interface = ICreatePublishEntryDataFactory;
+    type Error = FactoryError;
+    type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<ICreatePublishEntryDataResponse<TValues>, FactoryError>;
+    type Response<TValues extends CmsEntryValues = CmsEntryValues> = ICreatePublishEntryDataResponse<TValues>;
+}
+export {};

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/abstractions.js

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

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/abstractions.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { GetLatestRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\nimport type { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\n\nexport interface ICreatePublishEntryDataResponse<TValues extends CmsEntryValues = CmsEntryValues> {\n    entry: CmsEntry<TValues>;\n}\n\n/**\n * Expected failures of building the data of an entry being published.\n */\nexport interface ICreatePublishEntryDataFactoryErrors {\n    latest: GetLatestRevisionByEntryIdUseCase.Error;\n    validation: EntryValidationError;\n}\n\ntype FactoryError =\n    ICreatePublishEntryDataFactoryErrors[keyof ICreatePublishEntryDataFactoryErrors];\n\nexport interface ICreatePublishEntryDataFactory {\n    create<TValues extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        originalEntry: CmsEntry<TValues>\n    ): Promise<Result<ICreatePublishEntryDataResponse<TValues>, FactoryError>>;\n}\n\nexport const CreatePublishEntryDataFactory = createAbstraction<ICreatePublishEntryDataFactory>(\n    \"Cms/Entry/CreatePublishEntryDataFactory\"\n);\n\nexport namespace CreatePublishEntryDataFactory {\n    export type Interface = ICreatePublishEntryDataFactory;\n    export type Error = FactoryError;\n    export type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<\n        ICreatePublishEntryDataResponse<TValues>,\n        FactoryError\n    >;\n    export type Response<TValues extends CmsEntryValues = CmsEntryValues> =\n        ICreatePublishEntryDataResponse<TValues>;\n}\n"],"names":["CreatePublishEntryDataFactory","createAbstraction"],"mappings":";AA2BO,MAAMA,gCAAgCC,kBACzC"}

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/feature.d.ts

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

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/feature.js

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

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/feature.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreatePublishEntryDataFactory } from \"./CreatePublishEntryDataFactory.js\";\n\nexport const CreatePublishEntryDataFactoryFeature = createFeature({\n    name: \"CreatePublishEntryDataFactory\",\n    register(container) {\n        container.register(CreatePublishEntryDataFactory).inSingletonScope();\n    }\n});\n"],"names":["CreatePublishEntryDataFactoryFeature","createFeature","container","CreatePublishEntryDataFactory"],"mappings":";;AAGO,MAAMA,uCAAuCC,cAAc;IAC9D,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,+BAA+B,gBAAgB;IACtE;AACJ"}

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/index.d.ts

@@ -0,0 +1,2 @@
+export { CreatePublishEntryDataFactory } from "./abstractions.js";
+export { CreatePublishEntryDataFactoryFeature } from "./feature.js";

package/features/contentEntry/entryDataFactories/CreatePublishEntryDataFactory/index.js

@@ -0,0 +1,2 @@
+export { CreatePublishEntryDataFactory } from "./abstractions.js";
+export { CreatePublishEntryDataFactoryFeature } from "./feature.js";

package/features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/CreateRepublishEntryDataFactory.d.ts

@@ -0,0 +1,16 @@
+import { CreateRepublishEntryDataFactory as FactoryAbstraction, type ICreateRepublishEntryDataFactory } from "./abstractions.js";
+import { CmsContext } from "../../../../features/shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../../types/index.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+declare class CreateRepublishEntryDataFactoryImpl implements ICreateRepublishEntryDataFactory {
+    private readonly cmsContext;
+    private readonly identityContext;
+    private readonly getLatestRevision;
+    constructor(cmsContext: CmsContext.Interface, identityContext: IdentityContext.Interface, getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface);
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, originalEntry: CmsEntry<TValues>): Promise<FactoryAbstraction.Return<TValues>>;
+}
+export declare const CreateRepublishEntryDataFactory: typeof CreateRepublishEntryDataFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ICreateRepublishEntryDataFactory>;
+};
+export {};

package/features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/CreateRepublishEntryDataFactory.js

@@ -0,0 +1,65 @@
+import { Result } from "@webiny/feature/api";
+import { CreateRepublishEntryDataFactory } from "./abstractions.js";
+import { CmsContext } from "../../../shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { referenceFieldsMapping } from "../../../../crud/contentEntry/referenceFieldsMapping.js";
+import { STATUS_PUBLISHED } from "../statuses.js";
+import { getIdentity } from "../../../../utils/identity.js";
+import { getDate } from "../../../../utils/date.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../GetLatestRevisionByEntryId/index.js";
+class CreateRepublishEntryDataFactoryImpl {
+    constructor(cmsContext, identityContext, getLatestRevision){
+        this.cmsContext = cmsContext;
+        this.identityContext = identityContext;
+        this.getLatestRevision = getLatestRevision;
+    }
+    async create(model, originalEntry) {
+        const latestResult = await this.getLatestRevision.execute(model, {
+            id: originalEntry.entryId
+        });
+        if (latestResult.isFail()) return Result.fail(latestResult.error);
+        const latestEntry = latestResult.value;
+        const values = await referenceFieldsMapping({
+            context: this.cmsContext,
+            model,
+            values: originalEntry.values,
+            validateEntries: false
+        });
+        const currentDateTime = new Date().toISOString();
+        const currentIdentity = this.identityContext.getIdentity();
+        const entry = {
+            ...originalEntry,
+            status: STATUS_PUBLISHED,
+            savedOn: getDate(latestEntry.savedOn, originalEntry.savedOn),
+            modifiedOn: getDate(latestEntry.modifiedOn),
+            savedBy: getIdentity(latestEntry.savedBy, originalEntry.savedBy),
+            modifiedBy: getIdentity(latestEntry.modifiedBy),
+            firstPublishedOn: getDate(originalEntry.firstPublishedOn, currentDateTime),
+            firstPublishedBy: getIdentity(originalEntry.firstPublishedBy, currentIdentity),
+            lastPublishedOn: getDate(currentDateTime),
+            lastPublishedBy: getIdentity(currentIdentity),
+            revisionFirstPublishedOn: getDate(originalEntry.revisionFirstPublishedOn, currentDateTime),
+            revisionFirstPublishedBy: getIdentity(originalEntry.revisionFirstPublishedBy, currentIdentity),
+            revisionLastPublishedOn: getDate(currentDateTime),
+            revisionLastPublishedBy: getIdentity(currentIdentity),
+            values,
+            live: {
+                version: originalEntry.version
+            }
+        };
+        return Result.ok({
+            entry
+        });
+    }
+}
+const CreateRepublishEntryDataFactory_CreateRepublishEntryDataFactory = CreateRepublishEntryDataFactory.createImplementation({
+    implementation: CreateRepublishEntryDataFactoryImpl,
+    dependencies: [
+        CmsContext,
+        IdentityContext,
+        GetLatestRevisionByEntryIdUseCase
+    ]
+});
+export { CreateRepublishEntryDataFactory_CreateRepublishEntryDataFactory as CreateRepublishEntryDataFactory };
+
+//# sourceMappingURL=CreateRepublishEntryDataFactory.js.map

package/features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/CreateRepublishEntryDataFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/CreateRepublishEntryDataFactory.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/CreateRepublishEntryDataFactory.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateRepublishEntryDataFactory as FactoryAbstraction,\n    type ICreateRepublishEntryDataFactory\n} from \"./abstractions.js\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { referenceFieldsMapping } from \"~/crud/contentEntry/referenceFieldsMapping.js\";\nimport { STATUS_PUBLISHED } from \"../statuses.js\";\nimport { getIdentity } from \"~/utils/identity.js\";\nimport { getDate } from \"~/utils/date.js\";\nimport { GetLatestRevisionByEntryIdUseCase } from \"~/features/contentEntry/GetLatestRevisionByEntryId/index.js\";\n\nclass CreateRepublishEntryDataFactoryImpl implements ICreateRepublishEntryDataFactory {\n    public constructor(\n        private readonly cmsContext: CmsContext.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface\n    ) {}\n\n    public async create<TValues extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        originalEntry: CmsEntry<TValues>\n    ): Promise<FactoryAbstraction.Return<TValues>> {\n        const latestResult = await this.getLatestRevision.execute<TValues>(model, {\n            id: originalEntry.entryId\n        });\n        if (latestResult.isFail()) {\n            return Result.fail(latestResult.error);\n        }\n        const latestEntry = latestResult.value;\n\n        const values = await referenceFieldsMapping<TValues>({\n            context: this.cmsContext,\n            model,\n            values: originalEntry.values,\n            validateEntries: false\n        });\n\n        const currentDateTime = new Date().toISOString();\n        const currentIdentity = this.identityContext.getIdentity();\n\n        /**\n         * Republishing is not a content modification, so saved/modified meta fields are kept.\n         * Entry-level values are taken from the latest revision, because storage copies them\n         * onto the latest revision when a non-latest revision is republished. Revision-level\n         * values are the republished revision's own, and come from `originalEntry`.\n         */\n        const entry: CmsEntry<TValues> = {\n            ...originalEntry,\n            status: STATUS_PUBLISHED,\n            savedOn: getDate(latestEntry.savedOn, originalEntry.savedOn),\n            modifiedOn: getDate(latestEntry.modifiedOn),\n            savedBy: getIdentity(latestEntry.savedBy, originalEntry.savedBy),\n            modifiedBy: getIdentity(latestEntry.modifiedBy),\n            firstPublishedOn: getDate(originalEntry.firstPublishedOn, currentDateTime),\n            firstPublishedBy: getIdentity(originalEntry.firstPublishedBy, currentIdentity),\n            lastPublishedOn: getDate(currentDateTime),\n            lastPublishedBy: getIdentity(currentIdentity),\n            revisionFirstPublishedOn: getDate(\n                originalEntry.revisionFirstPublishedOn,\n                currentDateTime\n            ),\n            revisionFirstPublishedBy: getIdentity(\n                originalEntry.revisionFirstPublishedBy,\n                currentIdentity\n            ),\n            revisionLastPublishedOn: getDate(currentDateTime),\n            revisionLastPublishedBy: getIdentity(currentIdentity),\n            values,\n            live: {\n                version: originalEntry.version\n            }\n        };\n\n        return Result.ok({ entry });\n    }\n}\n\nexport const CreateRepublishEntryDataFactory = FactoryAbstraction.createImplementation({\n    implementation: CreateRepublishEntryDataFactoryImpl,\n    dependencies: [CmsContext, IdentityContext, GetLatestRevisionByEntryIdUseCase]\n});\n"],"names":["CreateRepublishEntryDataFactoryImpl","cmsContext","identityContext","getLatestRevision","model","originalEntry","latestResult","Result","latestEntry","values","referenceFieldsMapping","currentDateTime","Date","currentIdentity","entry","STATUS_PUBLISHED","getDate","getIdentity","CreateRepublishEntryDataFactory","FactoryAbstraction","CmsContext","IdentityContext","GetLatestRevisionByEntryIdUseCase"],"mappings":";;;;;;;;;AAcA,MAAMA;IACF,YACqBC,UAAgC,EAChCC,eAA0C,EAC1CC,iBAA8D,CACjF;aAHmBF,UAAU,GAAVA;aACAC,eAAe,GAAfA;aACAC,iBAAiB,GAAjBA;IAClB;IAEH,MAAa,OACTC,KAAe,EACfC,aAAgC,EACW;QAC3C,MAAMC,eAAe,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAUF,OAAO;YACtE,IAAIC,cAAc,OAAO;QAC7B;QACA,IAAIC,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAACD,aAAa,KAAK;QAEzC,MAAME,cAAcF,aAAa,KAAK;QAEtC,MAAMG,SAAS,MAAMC,uBAAgC;YACjD,SAAS,IAAI,CAAC,UAAU;YACxBN;YACA,QAAQC,cAAc,MAAM;YAC5B,iBAAiB;QACrB;QAEA,MAAMM,kBAAkB,IAAIC,OAAO,WAAW;QAC9C,MAAMC,kBAAkB,IAAI,CAAC,eAAe,CAAC,WAAW;QAQxD,MAAMC,QAA2B;YAC7B,GAAGT,aAAa;YAChB,QAAQU;YACR,SAASC,QAAQR,YAAY,OAAO,EAAEH,cAAc,OAAO;YAC3D,YAAYW,QAAQR,YAAY,UAAU;YAC1C,SAASS,YAAYT,YAAY,OAAO,EAAEH,cAAc,OAAO;YAC/D,YAAYY,YAAYT,YAAY,UAAU;YAC9C,kBAAkBQ,QAAQX,cAAc,gBAAgB,EAAEM;YAC1D,kBAAkBM,YAAYZ,cAAc,gBAAgB,EAAEQ;YAC9D,iBAAiBG,QAAQL;YACzB,iBAAiBM,YAAYJ;YAC7B,0BAA0BG,QACtBX,cAAc,wBAAwB,EACtCM;YAEJ,0BAA0BM,YACtBZ,cAAc,wBAAwB,EACtCQ;YAEJ,yBAAyBG,QAAQL;YACjC,yBAAyBM,YAAYJ;YACrCJ;YACA,MAAM;gBACF,SAASJ,cAAc,OAAO;YAClC;QACJ;QAEA,OAAOE,OAAO,EAAE,CAAC;YAAEO;QAAM;IAC7B;AACJ;AAEO,MAAMI,kEAAkCC,gCAAAA,oBAAuC,CAAC;IACnF,gBAAgBnB;IAChB,cAAc;QAACoB;QAAYC;QAAiBC;KAAkC;AAClF"}

package/features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/abstractions.d.ts

@@ -0,0 +1,24 @@
+import { type Result } from "@webiny/feature/api";
+import type { GetLatestRevisionByEntryIdUseCase } from "../../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../../types/index.js";
+export interface ICreateRepublishEntryDataResponse<TValues extends CmsEntryValues = CmsEntryValues> {
+    entry: CmsEntry<TValues>;
+}
+/**
+ * Expected failures of building the data of an entry being republished.
+ */
+export interface ICreateRepublishEntryDataFactoryErrors {
+    latest: GetLatestRevisionByEntryIdUseCase.Error;
+}
+type FactoryError = ICreateRepublishEntryDataFactoryErrors[keyof ICreateRepublishEntryDataFactoryErrors];
+export interface ICreateRepublishEntryDataFactory {
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, originalEntry: CmsEntry<TValues>): Promise<Result<ICreateRepublishEntryDataResponse<TValues>, FactoryError>>;
+}
+export declare const CreateRepublishEntryDataFactory: import("@webiny/di").Abstraction<ICreateRepublishEntryDataFactory>;
+export declare namespace CreateRepublishEntryDataFactory {
+    type Interface = ICreateRepublishEntryDataFactory;
+    type Error = FactoryError;
+    type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<ICreateRepublishEntryDataResponse<TValues>, FactoryError>;
+    type Response<TValues extends CmsEntryValues = CmsEntryValues> = ICreateRepublishEntryDataResponse<TValues>;
+}
+export {};

package/features/contentEntry/entryDataFactories/CreateRepublishEntryDataFactory/abstractions.js

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