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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { CreateUnpublishEntryDataFactory as FactoryAbstraction, type ICreateUnpublishEntryDataFactory } from "./abstractions.js";
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../../../../types/index.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+declare class CreateUnpublishEntryDataFactoryImpl implements ICreateUnpublishEntryDataFactory {
+    private readonly getLatestRevision;
+    constructor(getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface);
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, originalEntry: CmsEntry<TValues>): Promise<FactoryAbstraction.Return<TValues>>;
+}
+export declare const CreateUnpublishEntryDataFactory: typeof CreateUnpublishEntryDataFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ICreateUnpublishEntryDataFactory>;
+};
+export {};

package/features/contentEntry/entryDataFactories/CreateUnpublishEntryDataFactory/CreateUnpublishEntryDataFactory.js

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import { CreateUnpublishEntryDataFactory } from "./abstractions.js";
+import { STATUS_UNPUBLISHED } from "../statuses.js";
+import { getIdentity } from "../../../../utils/identity.js";
+import { getDate } from "../../../../utils/date.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../GetLatestRevisionByEntryId/index.js";
+class CreateUnpublishEntryDataFactoryImpl {
+    constructor(getLatestRevision){
+        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 entry = {
+            ...originalEntry,
+            status: STATUS_UNPUBLISHED,
+            savedOn: getDate(latestEntry.savedOn, originalEntry.savedOn),
+            modifiedOn: getDate(latestEntry.modifiedOn),
+            savedBy: getIdentity(latestEntry.savedBy, originalEntry.savedBy),
+            modifiedBy: getIdentity(latestEntry.modifiedBy),
+            live: null
+        };
+        return Result.ok({
+            entry
+        });
+    }
+}
+const CreateUnpublishEntryDataFactory_CreateUnpublishEntryDataFactory = CreateUnpublishEntryDataFactory.createImplementation({
+    implementation: CreateUnpublishEntryDataFactoryImpl,
+    dependencies: [
+        GetLatestRevisionByEntryIdUseCase
+    ]
+});
+export { CreateUnpublishEntryDataFactory_CreateUnpublishEntryDataFactory as CreateUnpublishEntryDataFactory };
+
+//# sourceMappingURL=CreateUnpublishEntryDataFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/CreateUnpublishEntryDataFactory/CreateUnpublishEntryDataFactory.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/CreateUnpublishEntryDataFactory/CreateUnpublishEntryDataFactory.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateUnpublishEntryDataFactory as FactoryAbstraction,\n    type ICreateUnpublishEntryDataFactory\n} from \"./abstractions.js\";\nimport type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\nimport { STATUS_UNPUBLISHED } 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 CreateUnpublishEntryDataFactoryImpl implements ICreateUnpublishEntryDataFactory {\n    public constructor(\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        /**\n         * Unpublishing 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 unpublished. Revision-level\n         * values are the unpublished revision's own, and come from `originalEntry`.\n         */\n        const entry: CmsEntry<TValues> = {\n            ...originalEntry,\n            status: STATUS_UNPUBLISHED,\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            live: null\n        };\n\n        return Result.ok({ entry });\n    }\n}\n\nexport const CreateUnpublishEntryDataFactory = FactoryAbstraction.createImplementation({\n    implementation: CreateUnpublishEntryDataFactoryImpl,\n    dependencies: [GetLatestRevisionByEntryIdUseCase]\n});\n"],"names":["CreateUnpublishEntryDataFactoryImpl","getLatestRevision","model","originalEntry","latestResult","Result","latestEntry","entry","STATUS_UNPUBLISHED","getDate","getIdentity","CreateUnpublishEntryDataFactory","FactoryAbstraction","GetLatestRevisionByEntryIdUseCase"],"mappings":";;;;;;AAWA,MAAMA;IACF,YACqBC,iBAA8D,CACjF;aADmBA,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;QAQtC,MAAMG,QAA2B;YAC7B,GAAGJ,aAAa;YAChB,QAAQK;YACR,SAASC,QAAQH,YAAY,OAAO,EAAEH,cAAc,OAAO;YAC3D,YAAYM,QAAQH,YAAY,UAAU;YAC1C,SAASI,YAAYJ,YAAY,OAAO,EAAEH,cAAc,OAAO;YAC/D,YAAYO,YAAYJ,YAAY,UAAU;YAC9C,MAAM;QACV;QAEA,OAAOD,OAAO,EAAE,CAAC;YAAEE;QAAM;IAC7B;AACJ;AAEO,MAAMI,kEAAkCC,gCAAAA,oBAAuC,CAAC;IACnF,gBAAgBZ;IAChB,cAAc;QAACa;KAAkC;AACrD"}

package/features/contentEntry/entryDataFactories/CreateUnpublishEntryDataFactory/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 ICreateUnpublishEntryDataResponse<TValues extends CmsEntryValues = CmsEntryValues> {
+    entry: CmsEntry<TValues>;
+}
+/**
+ * Expected failures of building the data of an entry being unpublished.
+ */
+export interface ICreateUnpublishEntryDataFactoryErrors {
+    latest: GetLatestRevisionByEntryIdUseCase.Error;
+}
+type FactoryError = ICreateUnpublishEntryDataFactoryErrors[keyof ICreateUnpublishEntryDataFactoryErrors];
+export interface ICreateUnpublishEntryDataFactory {
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, originalEntry: CmsEntry<TValues>): Promise<Result<ICreateUnpublishEntryDataResponse<TValues>, FactoryError>>;
+}
+export declare const CreateUnpublishEntryDataFactory: import("@webiny/di").Abstraction<ICreateUnpublishEntryDataFactory>;
+export declare namespace CreateUnpublishEntryDataFactory {
+    type Interface = ICreateUnpublishEntryDataFactory;
+    type Error = FactoryError;
+    type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<ICreateUnpublishEntryDataResponse<TValues>, FactoryError>;
+    type Response<TValues extends CmsEntryValues = CmsEntryValues> = ICreateUnpublishEntryDataResponse<TValues>;
+}
+export {};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/features/contentEntry/entryDataFactories/EntryDataFactoriesFeature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateEntryDataFactoryFeature } from "./CreateEntryDataFactory/feature.js";
+import { UpdateEntryDataFactoryFeature } from "./UpdateEntryDataFactory/feature.js";
+import { CreateEntryRevisionFromDataFactoryFeature } from "./CreateEntryRevisionFromDataFactory/feature.js";
+import { CreatePublishEntryDataFactoryFeature } from "./CreatePublishEntryDataFactory/feature.js";
+import { CreateUnpublishEntryDataFactoryFeature } from "./CreateUnpublishEntryDataFactory/feature.js";
+import { CreateRepublishEntryDataFactoryFeature } from "./CreateRepublishEntryDataFactory/feature.js";
+const EntryDataFactoriesFeature = createFeature({
+    name: "EntryDataFactories",
+    register (container) {
+        CreateEntryDataFactoryFeature.register(container);
+        UpdateEntryDataFactoryFeature.register(container);
+        CreateEntryRevisionFromDataFactoryFeature.register(container);
+        CreatePublishEntryDataFactoryFeature.register(container);
+        CreateUnpublishEntryDataFactoryFeature.register(container);
+        CreateRepublishEntryDataFactoryFeature.register(container);
+    }
+});
+export { EntryDataFactoriesFeature };
+
+//# sourceMappingURL=EntryDataFactoriesFeature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/EntryDataFactoriesFeature.js","sources":["../../../../src/features/contentEntry/entryDataFactories/EntryDataFactoriesFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateEntryDataFactoryFeature } from \"./CreateEntryDataFactory/feature.js\";\nimport { UpdateEntryDataFactoryFeature } from \"./UpdateEntryDataFactory/feature.js\";\nimport { CreateEntryRevisionFromDataFactoryFeature } from \"./CreateEntryRevisionFromDataFactory/feature.js\";\nimport { CreatePublishEntryDataFactoryFeature } from \"./CreatePublishEntryDataFactory/feature.js\";\nimport { CreateUnpublishEntryDataFactoryFeature } from \"./CreateUnpublishEntryDataFactory/feature.js\";\nimport { CreateRepublishEntryDataFactoryFeature } from \"./CreateRepublishEntryDataFactory/feature.js\";\n\nexport const EntryDataFactoriesFeature = createFeature({\n    name: \"EntryDataFactories\",\n    register(container) {\n        CreateEntryDataFactoryFeature.register(container);\n        UpdateEntryDataFactoryFeature.register(container);\n        CreateEntryRevisionFromDataFactoryFeature.register(container);\n        CreatePublishEntryDataFactoryFeature.register(container);\n        CreateUnpublishEntryDataFactoryFeature.register(container);\n        CreateRepublishEntryDataFactoryFeature.register(container);\n    }\n});\n"],"names":["EntryDataFactoriesFeature","createFeature","container","CreateEntryDataFactoryFeature","UpdateEntryDataFactoryFeature","CreateEntryRevisionFromDataFactoryFeature","CreatePublishEntryDataFactoryFeature","CreateUnpublishEntryDataFactoryFeature","CreateRepublishEntryDataFactoryFeature"],"mappings":";;;;;;;AAQO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdC,8BAA8B,QAAQ,CAACD;QACvCE,8BAA8B,QAAQ,CAACF;QACvCG,0CAA0C,QAAQ,CAACH;QACnDI,qCAAqC,QAAQ,CAACJ;QAC9CK,uCAAuC,QAAQ,CAACL;QAChDM,uCAAuC,QAAQ,CAACN;IACpD;AACJ"}

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

@@ -0,0 +1,18 @@
+import { type IUpdateEntryDataFactory, UpdateEntryDataFactory as FactoryAbstraction } 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, UpdateCmsEntryInput, UpdateCmsEntryOptionsInput } from "../../../../types/index.js";
+import { ModelToAstConverter } from "../../../../features/contentModel/ModelToAstConverter/abstractions.js";
+import { GetLatestRevisionByEntryIdUseCase } from "../../../../features/contentEntry/GetLatestRevisionByEntryId/index.js";
+declare class UpdateEntryDataFactoryImpl implements IUpdateEntryDataFactory {
+    private readonly cmsContext;
+    private readonly identityContext;
+    private readonly modelToAstConverter;
+    private readonly getLatestRevision;
+    constructor(cmsContext: CmsContext.Interface, identityContext: IdentityContext.Interface, modelToAstConverter: ModelToAstConverter.Interface, getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface);
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, rawInput: UpdateCmsEntryInput<TValues>, originalEntry: CmsEntry<TValues>, options?: UpdateCmsEntryOptionsInput): Promise<FactoryAbstraction.Return<TValues>>;
+}
+export declare const UpdateEntryDataFactory: typeof UpdateEntryDataFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IUpdateEntryDataFactory>;
+};
+export {};

package/features/contentEntry/entryDataFactories/UpdateEntryDataFactory/UpdateEntryDataFactory.js

@@ -0,0 +1,150 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateEntryDataFactory } from "./abstractions.js";
+import { 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 { validateModelEntryData } from "../../../../crud/contentEntry/entryDataValidation.js";
+import { EntryValidationError } from "../../../../domain/contentEntry/errors.js";
+import { referenceFieldsMapping } from "../../../../crud/contentEntry/referenceFieldsMapping.js";
+import { mapAndCleanUpdatedInputData } from "../mapAndCleanUpdatedInputData.js";
+import { getSystem } from "../system.js";
+import { getExpiresAt } from "../expiresAt.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 allowedEntryStatus = [
+    "draft",
+    "published",
+    "unpublished"
+];
+const transformEntryStatus = (status)=>allowedEntryStatus.includes(status) ? status : "draft";
+class UpdateEntryDataFactoryImpl {
+    constructor(cmsContext, identityContext, modelToAstConverter, getLatestRevision){
+        this.cmsContext = cmsContext;
+        this.identityContext = identityContext;
+        this.modelToAstConverter = modelToAstConverter;
+        this.getLatestRevision = getLatestRevision;
+    }
+    async create(model, rawInput, originalEntry, options) {
+        const latestResult = await this.getLatestRevision.execute(model, {
+            id: originalEntry.entryId
+        });
+        if (latestResult.isFail()) return Result.fail(latestResult.error);
+        const latestEntry = latestResult.value;
+        const cleanedValues = mapAndCleanUpdatedInputData(model, rawInput?.values || {});
+        const invalidFields = await validateModelEntryData({
+            context: this.cmsContext,
+            model,
+            values: cleanedValues,
+            entry: originalEntry,
+            skipValidation: options?.skipValidation
+        });
+        if (invalidFields.length > 0) return Result.fail(new EntryValidationError("Validation failed.", invalidFields));
+        const mergedValues = {
+            ...originalEntry.values,
+            ...cleanedValues
+        };
+        const modelAst = this.modelToAstConverter.toAst(model);
+        await ensureItemIds(modelAst, mergedValues);
+        const values = await referenceFieldsMapping({
+            context: this.cmsContext,
+            model,
+            values: mergedValues,
+            validateEntries: false
+        });
+        const currentIdentity = this.identityContext.getIdentity();
+        const currentDateTime = new Date();
+        const contentChanged = hasEntryContentChanged({
+            values,
+            baselineValues: originalEntry.values
+        });
+        const entryLevelSaved = contentChanged ? {
+            savedOn: currentDateTime,
+            modifiedOn: currentDateTime,
+            savedBy: currentIdentity,
+            modifiedBy: currentIdentity
+        } : {
+            savedOn: latestEntry.savedOn,
+            modifiedOn: latestEntry.modifiedOn,
+            savedBy: latestEntry.savedBy,
+            modifiedBy: latestEntry.modifiedBy
+        };
+        const revisionLevelSaved = contentChanged ? {
+            revisionSavedOn: currentDateTime,
+            revisionModifiedOn: currentDateTime,
+            revisionSavedBy: currentIdentity,
+            revisionModifiedBy: currentIdentity
+        } : {
+            revisionSavedOn: originalEntry.revisionSavedOn,
+            revisionModifiedOn: originalEntry.revisionModifiedOn,
+            revisionSavedBy: originalEntry.revisionSavedBy,
+            revisionModifiedBy: originalEntry.revisionModifiedBy
+        };
+        const entry = {
+            ...originalEntry,
+            revisionCreatedOn: getDate(rawInput.revisionCreatedOn, originalEntry.revisionCreatedOn),
+            revisionModifiedOn: getDate(rawInput.revisionModifiedOn, revisionLevelSaved.revisionModifiedOn),
+            revisionSavedOn: getDate(rawInput.revisionSavedOn, revisionLevelSaved.revisionSavedOn),
+            revisionDeletedOn: getDate(rawInput.revisionDeletedOn, originalEntry.revisionDeletedOn),
+            revisionRestoredOn: getDate(rawInput.revisionRestoredOn, originalEntry.revisionRestoredOn),
+            revisionFirstPublishedOn: getDate(rawInput.revisionFirstPublishedOn, originalEntry.revisionFirstPublishedOn),
+            revisionLastPublishedOn: getDate(rawInput.revisionLastPublishedOn, originalEntry.revisionLastPublishedOn),
+            revisionCreatedBy: getIdentity(rawInput.revisionCreatedBy, originalEntry.revisionCreatedBy),
+            revisionModifiedBy: getIdentity(rawInput.revisionModifiedBy, revisionLevelSaved.revisionModifiedBy),
+            revisionSavedBy: getIdentity(rawInput.revisionSavedBy, revisionLevelSaved.revisionSavedBy),
+            revisionDeletedBy: getIdentity(rawInput.revisionDeletedBy, originalEntry.revisionDeletedBy),
+            revisionRestoredBy: getIdentity(rawInput.revisionRestoredBy, originalEntry.revisionRestoredBy),
+            revisionFirstPublishedBy: getIdentity(rawInput.revisionFirstPublishedBy, originalEntry.revisionFirstPublishedBy),
+            revisionLastPublishedBy: getIdentity(rawInput.revisionLastPublishedBy, originalEntry.revisionLastPublishedBy),
+            createdOn: getDate(rawInput.createdOn, latestEntry.createdOn),
+            savedOn: getDate(rawInput.savedOn, entryLevelSaved.savedOn),
+            modifiedOn: getDate(rawInput.modifiedOn, entryLevelSaved.modifiedOn),
+            deletedOn: getDate(rawInput.deletedOn, latestEntry.deletedOn),
+            restoredOn: getDate(rawInput.restoredOn, latestEntry.restoredOn),
+            firstPublishedOn: getDate(rawInput.firstPublishedOn, latestEntry.firstPublishedOn),
+            lastPublishedOn: getDate(rawInput.lastPublishedOn, latestEntry.lastPublishedOn),
+            createdBy: getIdentity(rawInput.createdBy, latestEntry.createdBy),
+            savedBy: getIdentity(rawInput.savedBy, entryLevelSaved.savedBy),
+            modifiedBy: getIdentity(rawInput.modifiedBy, entryLevelSaved.modifiedBy),
+            deletedBy: getIdentity(rawInput.deletedBy, latestEntry.deletedBy),
+            restoredBy: getIdentity(rawInput.restoredBy, latestEntry.restoredBy),
+            firstPublishedBy: getIdentity(rawInput.firstPublishedBy, latestEntry.firstPublishedBy),
+            lastPublishedBy: getIdentity(rawInput.lastPublishedBy, latestEntry.lastPublishedBy),
+            values,
+            status: transformEntryStatus(originalEntry.status),
+            system: getSystem({
+                input: rawInput,
+                original: originalEntry
+            }),
+            live: originalEntry.live,
+            expiresAt: getExpiresAt({
+                expiresAt: rawInput.expiresAt
+            }, originalEntry)
+        };
+        const folderId = rawInput.wbyAco_location?.folderId;
+        if (folderId) entry.location = {
+            folderId
+        };
+        return Result.ok({
+            entry,
+            input: {
+                ...rawInput,
+                values: structuredClone(values)
+            }
+        });
+    }
+}
+const UpdateEntryDataFactory_UpdateEntryDataFactory = UpdateEntryDataFactory.createImplementation({
+    implementation: UpdateEntryDataFactoryImpl,
+    dependencies: [
+        CmsContext,
+        IdentityContext,
+        ModelToAstConverter,
+        GetLatestRevisionByEntryIdUseCase
+    ]
+});
+export { UpdateEntryDataFactory_UpdateEntryDataFactory as UpdateEntryDataFactory };
+
+//# sourceMappingURL=UpdateEntryDataFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/UpdateEntryDataFactory/UpdateEntryDataFactory.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/UpdateEntryDataFactory/UpdateEntryDataFactory.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    type IUpdateEntryDataFactory,\n    UpdateEntryDataFactory as FactoryAbstraction\n} from \"./abstractions.js\";\nimport { CmsContext } from \"~/features/shared/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport type {\n    CmsEntry,\n    CmsEntryStatus,\n    CmsEntryValues,\n    CmsModel,\n    UpdateCmsEntryInput,\n    UpdateCmsEntryOptionsInput\n} from \"~/types/index.js\";\nimport { getDate } from \"~/utils/date.js\";\nimport { getIdentity } from \"~/utils/identity.js\";\nimport { validateModelEntryData } from \"~/crud/contentEntry/entryDataValidation.js\";\nimport { EntryValidationError } from \"~/domain/contentEntry/errors.js\";\nimport { referenceFieldsMapping } from \"~/crud/contentEntry/referenceFieldsMapping.js\";\nimport { mapAndCleanUpdatedInputData } from \"../mapAndCleanUpdatedInputData.js\";\nimport { getSystem } from \"../system.js\";\nimport { getExpiresAt } from \"../expiresAt.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 allowedEntryStatus: string[] = [\"draft\", \"published\", \"unpublished\"];\n\nconst transformEntryStatus = (status: CmsEntryStatus | string): CmsEntryStatus => {\n    return allowedEntryStatus.includes(status) ? (status as CmsEntryStatus) : \"draft\";\n};\n\nclass UpdateEntryDataFactoryImpl implements IUpdateEntryDataFactory {\n    public constructor(\n        private readonly cmsContext: CmsContext.Interface,\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly modelToAstConverter: ModelToAstConverter.Interface,\n        private readonly getLatestRevision: GetLatestRevisionByEntryIdUseCase.Interface\n    ) {}\n\n    public async create<TValues extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        rawInput: UpdateCmsEntryInput<TValues>,\n        originalEntry: CmsEntry<TValues>,\n        options?: UpdateCmsEntryOptionsInput\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 cleanedValues = mapAndCleanUpdatedInputData<TValues>(\n            model,\n            rawInput?.values || ({} as TValues)\n        );\n\n        const invalidFields = await validateModelEntryData({\n            context: this.cmsContext,\n            model,\n            values: cleanedValues,\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 mergedValues: TValues = {\n            ...originalEntry.values,\n            ...cleanedValues\n        };\n\n        const modelAst = this.modelToAstConverter.toAst(model);\n        await ensureItemIds(modelAst, mergedValues);\n\n        const values = await referenceFieldsMapping<TValues>({\n            context: this.cmsContext,\n            model,\n            values: mergedValues,\n            validateEntries: false\n        });\n\n        const currentIdentity = this.identityContext.getIdentity();\n        const currentDateTime = new Date();\n\n        /**\n         * Saving without changing the content (e.g. clicking \"Save\" without editing anything) is\n         * not a modification, so the saved/modified meta fields are kept. Entry-level values are\n         * then taken from the latest revision, because storage copies them onto the latest\n         * revision when a non-latest revision is updated. Revision-level values are this\n         * revision's own. Explicitly provided meta field values always take precedence.\n         */\n        const contentChanged = hasEntryContentChanged({\n            values,\n            baselineValues: originalEntry.values\n        });\n\n        const entryLevelSaved = contentChanged\n            ? {\n                  savedOn: currentDateTime,\n                  modifiedOn: currentDateTime,\n                  savedBy: currentIdentity,\n                  modifiedBy: currentIdentity\n              }\n            : {\n                  savedOn: latestEntry.savedOn,\n                  modifiedOn: latestEntry.modifiedOn,\n                  savedBy: latestEntry.savedBy,\n                  modifiedBy: latestEntry.modifiedBy\n              };\n\n        const revisionLevelSaved = contentChanged\n            ? {\n                  revisionSavedOn: currentDateTime,\n                  revisionModifiedOn: currentDateTime,\n                  revisionSavedBy: currentIdentity,\n                  revisionModifiedBy: currentIdentity\n              }\n            : {\n                  revisionSavedOn: originalEntry.revisionSavedOn,\n                  revisionModifiedOn: originalEntry.revisionModifiedOn,\n                  revisionSavedBy: originalEntry.revisionSavedBy,\n                  revisionModifiedBy: originalEntry.revisionModifiedBy\n              };\n\n        const entry: CmsEntry<TValues> = {\n            ...originalEntry,\n            revisionCreatedOn: getDate(rawInput.revisionCreatedOn, originalEntry.revisionCreatedOn),\n            revisionModifiedOn: getDate(\n                rawInput.revisionModifiedOn,\n                revisionLevelSaved.revisionModifiedOn\n            ),\n            revisionSavedOn: getDate(rawInput.revisionSavedOn, revisionLevelSaved.revisionSavedOn),\n            revisionDeletedOn: getDate(rawInput.revisionDeletedOn, originalEntry.revisionDeletedOn),\n            revisionRestoredOn: getDate(\n                rawInput.revisionRestoredOn,\n                originalEntry.revisionRestoredOn\n            ),\n            revisionFirstPublishedOn: getDate(\n                rawInput.revisionFirstPublishedOn,\n                originalEntry.revisionFirstPublishedOn\n            ),\n            revisionLastPublishedOn: getDate(\n                rawInput.revisionLastPublishedOn,\n                originalEntry.revisionLastPublishedOn\n            ),\n            revisionCreatedBy: getIdentity(\n                rawInput.revisionCreatedBy,\n                originalEntry.revisionCreatedBy\n            )!,\n            revisionModifiedBy: getIdentity(\n                rawInput.revisionModifiedBy,\n                revisionLevelSaved.revisionModifiedBy\n            ),\n            revisionSavedBy: getIdentity(\n                rawInput.revisionSavedBy,\n                revisionLevelSaved.revisionSavedBy\n            )!,\n            revisionDeletedBy: getIdentity(\n                rawInput.revisionDeletedBy,\n                originalEntry.revisionDeletedBy\n            ),\n            revisionRestoredBy: getIdentity(\n                rawInput.revisionRestoredBy,\n                originalEntry.revisionRestoredBy\n            ),\n            revisionFirstPublishedBy: getIdentity(\n                rawInput.revisionFirstPublishedBy,\n                originalEntry.revisionFirstPublishedBy\n            ),\n            revisionLastPublishedBy: getIdentity(\n                rawInput.revisionLastPublishedBy,\n                originalEntry.revisionLastPublishedBy\n            ),\n            createdOn: getDate(rawInput.createdOn, latestEntry.createdOn),\n            savedOn: getDate(rawInput.savedOn, entryLevelSaved.savedOn),\n            modifiedOn: getDate(rawInput.modifiedOn, entryLevelSaved.modifiedOn),\n            deletedOn: getDate(rawInput.deletedOn, latestEntry.deletedOn),\n            restoredOn: getDate(rawInput.restoredOn, latestEntry.restoredOn),\n            firstPublishedOn: getDate(rawInput.firstPublishedOn, latestEntry.firstPublishedOn),\n            lastPublishedOn: getDate(rawInput.lastPublishedOn, latestEntry.lastPublishedOn),\n            createdBy: getIdentity(rawInput.createdBy, latestEntry.createdBy)!,\n            savedBy: getIdentity(rawInput.savedBy, entryLevelSaved.savedBy)!,\n            modifiedBy: getIdentity(rawInput.modifiedBy, entryLevelSaved.modifiedBy),\n            deletedBy: getIdentity(rawInput.deletedBy, latestEntry.deletedBy),\n            restoredBy: getIdentity(rawInput.restoredBy, latestEntry.restoredBy),\n            firstPublishedBy: getIdentity(rawInput.firstPublishedBy, latestEntry.firstPublishedBy),\n            lastPublishedBy: getIdentity(rawInput.lastPublishedBy, latestEntry.lastPublishedBy),\n            values,\n            status: transformEntryStatus(originalEntry.status),\n            system: getSystem({\n                input: rawInput,\n                original: originalEntry\n            }),\n            live: originalEntry.live,\n            expiresAt: getExpiresAt({ expiresAt: rawInput.expiresAt }, originalEntry)\n        };\n\n        const folderId = rawInput.wbyAco_location?.folderId;\n        if (folderId) {\n            entry.location = {\n                folderId\n            };\n        }\n\n        return Result.ok({\n            entry,\n            input: {\n                ...rawInput,\n                values: structuredClone(values)\n            }\n        });\n    }\n}\n\nexport const UpdateEntryDataFactory = FactoryAbstraction.createImplementation({\n    implementation: UpdateEntryDataFactoryImpl,\n    dependencies: [\n        CmsContext,\n        IdentityContext,\n        ModelToAstConverter,\n        GetLatestRevisionByEntryIdUseCase\n    ]\n});\n"],"names":["allowedEntryStatus","transformEntryStatus","status","UpdateEntryDataFactoryImpl","cmsContext","identityContext","modelToAstConverter","getLatestRevision","model","rawInput","originalEntry","options","latestResult","Result","latestEntry","cleanedValues","mapAndCleanUpdatedInputData","invalidFields","validateModelEntryData","EntryValidationError","mergedValues","modelAst","ensureItemIds","values","referenceFieldsMapping","currentIdentity","currentDateTime","Date","contentChanged","hasEntryContentChanged","entryLevelSaved","revisionLevelSaved","entry","getDate","getIdentity","getSystem","getExpiresAt","folderId","structuredClone","UpdateEntryDataFactory","FactoryAbstraction","CmsContext","IdentityContext","ModelToAstConverter","GetLatestRevisionByEntryIdUseCase"],"mappings":"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"}

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

@@ -0,0 +1,27 @@
+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, UpdateCmsEntryInput, UpdateCmsEntryOptionsInput } from "../../../../types/index.js";
+export interface IUpdateEntryDataResponse<TValues extends CmsEntryValues = CmsEntryValues> {
+    entry: CmsEntry<TValues>;
+    input: UpdateCmsEntryInput<TValues>;
+}
+/**
+ * Expected failures of building the data of an entry being updated.
+ */
+export interface IUpdateEntryDataFactoryErrors {
+    latest: GetLatestRevisionByEntryIdUseCase.Error;
+    validation: EntryValidationError;
+}
+type FactoryError = IUpdateEntryDataFactoryErrors[keyof IUpdateEntryDataFactoryErrors];
+export interface IUpdateEntryDataFactory {
+    create<TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, rawInput: UpdateCmsEntryInput<TValues>, originalEntry: CmsEntry<TValues>, options?: UpdateCmsEntryOptionsInput): Promise<Result<IUpdateEntryDataResponse<TValues>, FactoryError>>;
+}
+export declare const UpdateEntryDataFactory: import("@webiny/di").Abstraction<IUpdateEntryDataFactory>;
+export declare namespace UpdateEntryDataFactory {
+    type Interface = IUpdateEntryDataFactory;
+    type Error = FactoryError;
+    type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<IUpdateEntryDataResponse<TValues>, FactoryError>;
+    type Response<TValues extends CmsEntryValues = CmsEntryValues> = IUpdateEntryDataResponse<TValues>;
+}
+export {};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/UpdateEntryDataFactory/abstractions.js","sources":["../../../../../src/features/contentEntry/entryDataFactories/UpdateEntryDataFactory/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 {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    UpdateCmsEntryInput,\n    UpdateCmsEntryOptionsInput\n} from \"~/types/index.js\";\n\nexport interface IUpdateEntryDataResponse<TValues extends CmsEntryValues = CmsEntryValues> {\n    entry: CmsEntry<TValues>;\n    input: UpdateCmsEntryInput<TValues>;\n}\n\n/**\n * Expected failures of building the data of an entry being updated.\n */\nexport interface IUpdateEntryDataFactoryErrors {\n    latest: GetLatestRevisionByEntryIdUseCase.Error;\n    validation: EntryValidationError;\n}\n\ntype FactoryError = IUpdateEntryDataFactoryErrors[keyof IUpdateEntryDataFactoryErrors];\n\nexport interface IUpdateEntryDataFactory {\n    create<TValues extends CmsEntryValues = CmsEntryValues>(\n        model: CmsModel,\n        rawInput: UpdateCmsEntryInput<TValues>,\n        originalEntry: CmsEntry<TValues>,\n        options?: UpdateCmsEntryOptionsInput\n    ): Promise<Result<IUpdateEntryDataResponse<TValues>, FactoryError>>;\n}\n\nexport const UpdateEntryDataFactory = createAbstraction<IUpdateEntryDataFactory>(\n    \"Cms/Entry/UpdateEntryDataFactory\"\n);\n\nexport namespace UpdateEntryDataFactory {\n    export type Interface = IUpdateEntryDataFactory;\n    export type Error = FactoryError;\n    export type Return<TValues extends CmsEntryValues = CmsEntryValues> = Result<\n        IUpdateEntryDataResponse<TValues>,\n        FactoryError\n    >;\n    export type Response<TValues extends CmsEntryValues = CmsEntryValues> =\n        IUpdateEntryDataResponse<TValues>;\n}\n"],"names":["UpdateEntryDataFactory","createAbstraction"],"mappings":";AAmCO,MAAMA,yBAAyBC,kBAClC"}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+import type { CmsEntry } from "../../../types/index.js";
+export interface IRawInput {
+    expiresAt: Date | number | null | undefined;
+}
+export declare const getExpiresAt: (input: IRawInput, original?: CmsEntry) => number | null;

package/features/contentEntry/entryDataFactories/expiresAt.js

@@ -0,0 +1,9 @@
+const getExpiresAt = (input, original)=>{
+    if (void 0 === input.expiresAt) return original?.expiresAt ?? null;
+    if (input.expiresAt instanceof Date) return input.expiresAt.getTime() / 1000;
+    if ("number" == typeof input.expiresAt && !isNaN(input.expiresAt) && input.expiresAt > 0) return input.expiresAt;
+    return null;
+};
+export { getExpiresAt };
+
+//# sourceMappingURL=expiresAt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/expiresAt.js","sources":["../../../../src/features/contentEntry/entryDataFactories/expiresAt.ts"],"sourcesContent":["import type { CmsEntry } from \"~/types/index.js\";\n\nexport interface IRawInput {\n    expiresAt: Date | number | null | undefined;\n}\n\nexport const getExpiresAt = (input: IRawInput, original?: CmsEntry): number | null => {\n    if (input.expiresAt === undefined) {\n        return original?.expiresAt ?? null;\n    } else if (input.expiresAt instanceof Date) {\n        return input.expiresAt.getTime() / 1000;\n    } else if (\n        typeof input.expiresAt === \"number\" &&\n        !isNaN(input.expiresAt) &&\n        input.expiresAt > 0\n    ) {\n        return input.expiresAt;\n    }\n    return null;\n};\n"],"names":["getExpiresAt","input","original","undefined","Date","isNaN"],"mappings":"AAMO,MAAMA,eAAe,CAACC,OAAkBC;IAC3C,IAAID,AAAoBE,WAApBF,MAAM,SAAS,EACf,OAAOC,UAAU,aAAa;IAC3B,IAAID,MAAM,SAAS,YAAYG,MAClC,OAAOH,MAAM,SAAS,CAAC,OAAO,KAAK;IAChC,IACH,AAA2B,YAA3B,OAAOA,MAAM,SAAS,IACtB,CAACI,MAAMJ,MAAM,SAAS,KACtBA,MAAM,SAAS,GAAG,GAElB,OAAOA,MAAM,SAAS;IAE1B,OAAO;AACX"}

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

@@ -0,0 +1,24 @@
+import type { CmsEntryValues } from "../../../types/index.js";
+export interface IHasEntryContentChangedParams<TValues extends CmsEntryValues = CmsEntryValues> {
+    /**
+     * The values as they will be stored (normalized).
+     */
+    values: TValues;
+    /**
+     * The values to compare against, as currently stored.
+     */
+    baselineValues: TValues;
+}
+/**
+ * Decides whether saving `values` changes the content of an entry. Used to keep the
+ * saved/modified meta fields untouched when an entry is saved without actual changes, e.g. when
+ * the "Save" button is clicked without editing anything.
+ *
+ * Only the content counts: moving an entry to another folder is not a content change, the same
+ * as with the dedicated move operation.
+ *
+ * Values must already be normalized the same way as the stored ones (item IDs assigned, reference
+ * fields mapped). A value that does not normalize identically is treated as a change, which only
+ * means the meta fields get updated, exactly as they did before this check existed.
+ */
+export declare const hasEntryContentChanged: <TValues extends CmsEntryValues = CmsEntryValues>(params: IHasEntryContentChangedParams<TValues>) => boolean;

package/features/contentEntry/entryDataFactories/hasEntryContentChanged.js

@@ -0,0 +1,13 @@
+import isEqual from "lodash/isEqual.js";
+const withoutEmptyKeys = (value)=>{
+    if (Array.isArray(value)) return value.map(withoutEmptyKeys);
+    if (null === value || "object" != typeof value || value instanceof Date) return value;
+    return Object.entries(value).reduce((result, [key, item])=>{
+        if (null != item) result[key] = withoutEmptyKeys(item);
+        return result;
+    }, {});
+};
+const hasEntryContentChanged = (params)=>!isEqual(withoutEmptyKeys(params.values), withoutEmptyKeys(params.baselineValues));
+export { hasEntryContentChanged };
+
+//# sourceMappingURL=hasEntryContentChanged.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/hasEntryContentChanged.js","sources":["../../../../src/features/contentEntry/entryDataFactories/hasEntryContentChanged.ts"],"sourcesContent":["import lodashIsEqual from \"lodash/isEqual.js\";\nimport type { CmsEntryValues } from \"~/types/index.js\";\n\n/**\n * Removes object keys with `null` or `undefined` values, recursively, so that a field that was\n * never set and a field that is explicitly empty compare as equal.\n */\nconst withoutEmptyKeys = (value: unknown): unknown => {\n    if (Array.isArray(value)) {\n        return value.map(withoutEmptyKeys);\n    }\n    if (value === null || typeof value !== \"object\" || value instanceof Date) {\n        return value;\n    }\n    return Object.entries(value).reduce<Record<string, unknown>>((result, [key, item]) => {\n        if (item !== null && item !== undefined) {\n            result[key] = withoutEmptyKeys(item);\n        }\n        return result;\n    }, {});\n};\n\nexport interface IHasEntryContentChangedParams<TValues extends CmsEntryValues = CmsEntryValues> {\n    /**\n     * The values as they will be stored (normalized).\n     */\n    values: TValues;\n    /**\n     * The values to compare against, as currently stored.\n     */\n    baselineValues: TValues;\n}\n\n/**\n * Decides whether saving `values` changes the content of an entry. Used to keep the\n * saved/modified meta fields untouched when an entry is saved without actual changes, e.g. when\n * the \"Save\" button is clicked without editing anything.\n *\n * Only the content counts: moving an entry to another folder is not a content change, the same\n * as with the dedicated move operation.\n *\n * Values must already be normalized the same way as the stored ones (item IDs assigned, reference\n * fields mapped). A value that does not normalize identically is treated as a change, which only\n * means the meta fields get updated, exactly as they did before this check existed.\n */\nexport const hasEntryContentChanged = <TValues extends CmsEntryValues = CmsEntryValues>(\n    params: IHasEntryContentChangedParams<TValues>\n): boolean => {\n    return !lodashIsEqual(withoutEmptyKeys(params.values), withoutEmptyKeys(params.baselineValues));\n};\n"],"names":["withoutEmptyKeys","value","Array","Date","Object","result","key","item","hasEntryContentChanged","params","lodashIsEqual"],"mappings":";AAOA,MAAMA,mBAAmB,CAACC;IACtB,IAAIC,MAAM,OAAO,CAACD,QACd,OAAOA,MAAM,GAAG,CAACD;IAErB,IAAIC,AAAU,SAAVA,SAAkB,AAAiB,YAAjB,OAAOA,SAAsBA,iBAAiBE,MAChE,OAAOF;IAEX,OAAOG,OAAO,OAAO,CAACH,OAAO,MAAM,CAA0B,CAACI,QAAQ,CAACC,KAAKC,KAAK;QAC7E,IAAIA,QAAAA,MACAF,MAAM,CAACC,IAAI,GAAGN,iBAAiBO;QAEnC,OAAOF;IACX,GAAG,CAAC;AACR;AAyBO,MAAMG,yBAAyB,CAClCC,SAEO,CAACC,QAAcV,iBAAiBS,OAAO,MAAM,GAAGT,iBAAiBS,OAAO,cAAc"}

package/{crud → features}/contentEntry/entryDataFactories/mapAndCleanUpdatedInputData.d.ts

@@ -1,5 +1,2 @@
 import type { CmsEntryValues, CmsModel } from "../../../types/index.js";
-/**
- * Cleans the update input entry data.
- */
 export declare const mapAndCleanUpdatedInputData: <TValues extends CmsEntryValues = CmsEntryValues>(model: CmsModel, input?: Partial<TValues>) => {};

package/features/contentEntry/entryDataFactories/mapAndCleanUpdatedInputData.js

@@ -0,0 +1,17 @@
+import error from "@webiny/error";
+const mapAndCleanUpdatedInputData = (model, input)=>{
+    if (!input) return {};
+    return model.fields.reduce((acc, field)=>{
+        if (!field.fieldId) throw new error("Field does not have an fieldId.", "MISSING_FIELD_ID", {
+            field
+        });
+        const key = field.fieldId;
+        const value = input[key];
+        if (void 0 === value) return acc;
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+export { mapAndCleanUpdatedInputData };
+
+//# sourceMappingURL=mapAndCleanUpdatedInputData.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentEntry/entryDataFactories/mapAndCleanUpdatedInputData.js","sources":["../../../../src/features/contentEntry/entryDataFactories/mapAndCleanUpdatedInputData.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type { CmsEntryValues, CmsModel } from \"~/types/index.js\";\n\nexport const mapAndCleanUpdatedInputData = <TValues extends CmsEntryValues = CmsEntryValues>(\n    model: CmsModel,\n    input?: Partial<TValues>\n) => {\n    if (!input) {\n        return {};\n    }\n    return model.fields.reduce<Partial<TValues>>((acc, field) => {\n        /* This should never happen, but let's make it sure.\n         * The fix would be for the user to add the fieldId on the field definition. */\n        if (!field.fieldId) {\n            throw new WebinyError(\"Field does not have an fieldId.\", \"MISSING_FIELD_ID\", {\n                field\n            });\n        }\n        /* We cannot set default value here because user might want to update only certain field values. */\n        const key = field.fieldId as keyof TValues;\n        const value = input[key];\n        if (value === undefined) {\n            return acc;\n        }\n        acc[key] = value;\n        return acc;\n    }, {});\n};\n"],"names":["mapAndCleanUpdatedInputData","model","input","acc","field","WebinyError","key","value","undefined"],"mappings":";AAGO,MAAMA,8BAA8B,CACvCC,OACAC;IAEA,IAAI,CAACA,OACD,OAAO,CAAC;IAEZ,OAAOD,MAAM,MAAM,CAAC,MAAM,CAAmB,CAACE,KAAKC;QAG/C,IAAI,CAACA,MAAM,OAAO,EACd,MAAM,IAAIC,MAAY,mCAAmC,oBAAoB;YACzED;QACJ;QAGJ,MAAME,MAAMF,MAAM,OAAO;QACzB,MAAMG,QAAQL,KAAK,CAACI,IAAI;QACxB,IAAIC,AAAUC,WAAVD,OACA,OAAOJ;QAEXA,GAAG,CAACG,IAAI,GAAGC;QACX,OAAOJ;IACX,GAAG,CAAC;AACR"}

package/features/contentEntry/entryDataFactories/statuses.js

@@ -0,0 +1,7 @@
+import { CONTENT_ENTRY_STATUS } from "../../../types/index.js";
+const STATUS_DRAFT = CONTENT_ENTRY_STATUS.DRAFT;
+const STATUS_PUBLISHED = CONTENT_ENTRY_STATUS.PUBLISHED;
+const STATUS_UNPUBLISHED = CONTENT_ENTRY_STATUS.UNPUBLISHED;
+export { STATUS_DRAFT, STATUS_PUBLISHED, STATUS_UNPUBLISHED };
+
+//# sourceMappingURL=statuses.js.map