@webiny/api-headless-cms-ddb 0.0.0-unstable.a4f3e4ea8b → 0.0.0-unstable.a85ef555b2

package/abstractions/CmsDdbDataLoaders.d.ts

@@ -0,0 +1,5 @@
+import type { IDataLoadersHandler } from "../types.js";
+export declare const CmsDdbDataLoaders: import("@webiny/di").Abstraction<IDataLoadersHandler>;
+export declare namespace CmsDdbDataLoaders {
+    type Interface = IDataLoadersHandler;
+}

package/abstractions/CmsDdbDataLoaders.js

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

package/abstractions/CmsDdbDataLoaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/CmsDdbDataLoaders.js","sources":["../../src/abstractions/CmsDdbDataLoaders.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IDataLoadersHandler } from \"~/types.js\";\n\nexport const CmsDdbDataLoaders = createAbstraction<IDataLoadersHandler>(\"Cms/Ddb/DataLoaders\");\n\nexport namespace CmsDdbDataLoaders {\n    export type Interface = IDataLoadersHandler;\n}\n"],"names":["CmsDdbDataLoaders","createAbstraction"],"mappings":";AAGO,MAAMA,oBAAoBC,kBAAuC"}

package/abstractions/CmsDdbEntryEntity.d.ts

@@ -0,0 +1,5 @@
+import type { IEntryEntity } from "../definitions/types.js";
+export declare const CmsDdbEntryEntity: import("@webiny/di").Abstraction<IEntryEntity>;
+export declare namespace CmsDdbEntryEntity {
+    type Interface = IEntryEntity;
+}

package/abstractions/CmsDdbEntryEntity.js

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

package/abstractions/CmsDdbEntryEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/CmsDdbEntryEntity.js","sources":["../../src/abstractions/CmsDdbEntryEntity.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEntryEntity } from \"~/definitions/types.js\";\n\nexport const CmsDdbEntryEntity = createAbstraction<IEntryEntity>(\"Cms/Ddb/EntryEntity\");\n\nexport namespace CmsDdbEntryEntity {\n    export type Interface = IEntryEntity;\n}\n"],"names":["CmsDdbEntryEntity","createAbstraction"],"mappings":";AAGO,MAAMA,oBAAoBC,kBAAgC"}

package/abstractions/CmsDdbGroupEntity.d.ts

@@ -0,0 +1,5 @@
+import type { IGroupEntity } from "../definitions/types.js";
+export declare const CmsDdbGroupEntity: import("@webiny/di").Abstraction<IGroupEntity>;
+export declare namespace CmsDdbGroupEntity {
+    type Interface = IGroupEntity;
+}

package/abstractions/CmsDdbGroupEntity.js

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

package/abstractions/CmsDdbGroupEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/CmsDdbGroupEntity.js","sources":["../../src/abstractions/CmsDdbGroupEntity.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IGroupEntity } from \"~/definitions/types.js\";\n\nexport const CmsDdbGroupEntity = createAbstraction<IGroupEntity>(\"Cms/Ddb/GroupEntity\");\n\nexport namespace CmsDdbGroupEntity {\n    export type Interface = IGroupEntity;\n}\n"],"names":["CmsDdbGroupEntity","createAbstraction"],"mappings":";AAGO,MAAMA,oBAAoBC,kBAAgC"}

package/abstractions/CmsDdbModelEntity.d.ts

@@ -0,0 +1,5 @@
+import type { IModelEntity } from "../definitions/types.js";
+export declare const CmsDdbModelEntity: import("@webiny/di").Abstraction<IModelEntity>;
+export declare namespace CmsDdbModelEntity {
+    type Interface = IModelEntity;
+}

package/abstractions/CmsDdbModelEntity.js

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

package/abstractions/CmsDdbModelEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/CmsDdbModelEntity.js","sources":["../../src/abstractions/CmsDdbModelEntity.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IModelEntity } from \"~/definitions/types.js\";\n\nexport const CmsDdbModelEntity = createAbstraction<IModelEntity>(\"Cms/Ddb/ModelEntity\");\n\nexport namespace CmsDdbModelEntity {\n    export type Interface = IModelEntity;\n}\n"],"names":["CmsDdbModelEntity","createAbstraction"],"mappings":";AAGO,MAAMA,oBAAoBC,kBAAgC"}

package/abstractions/CmsDdbTable.d.ts

@@ -0,0 +1,5 @@
+import type { ITable } from "@webiny/db-dynamodb";
+export declare const CmsDdbTable: import("@webiny/di").Abstraction<ITable<string, string, string>>;
+export declare namespace CmsDdbTable {
+    type Interface = ITable;
+}

package/abstractions/CmsDdbTable.js

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

package/abstractions/CmsDdbTable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstractions/CmsDdbTable.js","sources":["../../src/abstractions/CmsDdbTable.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ITable } from \"@webiny/db-dynamodb\";\n\nexport const CmsDdbTable = createAbstraction<ITable>(\"Cms/Ddb/Table\");\n\nexport namespace CmsDdbTable {\n    export type Interface = ITable;\n}\n"],"names":["CmsDdbTable","createAbstraction"],"mappings":";AAGO,MAAMA,cAAcC,kBAA0B"}

package/index.d.ts

@@ -1,2 +1,10 @@
-export * from "./plugins/index.js";
-export declare const registerDynamoDbStorageOperations: () => import("@webiny/handler").RegisterExtensionPlugin<import("@webiny/handler/types.js").Context>[];
+/**
+ * DynamoDB CMS storage. Register it once, in the root container. Tables and entities are built once
+ * per process; the storage operations are transient, and per-request state (the entry DataLoaders,
+ * the filter registries) is container scoped, so each request (child) container gets its own.
+ * Requires DynamoDBClient to be registered in the container first (via DbFeature).
+ */
+export declare const HeadlessCmsDdbFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/index.js

@@ -1,91 +1,47 @@
-import dynamoDb from "./dynamoDb/index.js";
 import { ENTITIES } from "./types.js";
 import { createGroupEntity } from "./definitions/group.js";
 import { createModelEntity } from "./definitions/model.js";
 import { createEntryEntity } from "./definitions/entry.js";
-import { createGroupsStorageOperations } from "./operations/group/index.js";
-import { createModelsStorageOperations } from "./operations/model/index.js";
-import { createEntriesStorageOperations } from "./operations/entry/index.js";
-import { createFilterCreatePlugins } from "@webiny/api-headless-cms-storage";
 import { createTable } from "./definitions/table.js";
-import { createRegisterExtensionPlugin } from "@webiny/handler";
 import { createFeature } from "@webiny/feature/api/index.js";
-import { StorageOperationsFactory } from "@webiny/api-headless-cms/exports/api/cms/storage.js";
 import { DynamoDBClient } from "@webiny/db-dynamodb";
-export * from "./plugins/index.js";
-const createDynamoDbStorageOperations = (params)=>{
-    const { table, plugins, container } = params;
-    const db = container.resolve(DynamoDBClient);
-    const documentClient = db.client;
-    const tableInstance = createTable({
-        name: table,
-        documentClient
-    });
-    const entities = {
-        groups: createGroupEntity({
+import { FilterUtilFeature } from "@webiny/db-dynamodb/feature/FilterUtil/feature.js";
+import { CmsDdbTable } from "./abstractions/CmsDdbTable.js";
+import { CmsDdbGroupEntity } from "./abstractions/CmsDdbGroupEntity.js";
+import { CmsDdbModelEntity } from "./abstractions/CmsDdbModelEntity.js";
+import { CmsDdbEntryEntity } from "./abstractions/CmsDdbEntryEntity.js";
+import { FilterRegistriesFeature } from "@webiny/api-headless-cms-storage";
+import { DdbGroupStorageOpsFeature } from "./operations/group/feature.js";
+import { DdbModelStorageOpsFeature } from "./operations/model/feature.js";
+import { DdbEntryStorageOpsFeature } from "./operations/entry/feature.js";
+const HeadlessCmsDdbFeature = createFeature({
+    name: "cms.storageOperations.ddb",
+    register: (container)=>{
+        FilterUtilFeature.register(container);
+        const db = container.resolve(DynamoDBClient);
+        const documentClient = db.client;
+        const tableInstance = createTable({
+            documentClient
+        });
+        container.registerInstance(CmsDdbTable, tableInstance);
+        container.registerInstance(CmsDdbGroupEntity, createGroupEntity({
             entityName: ENTITIES.GROUPS,
             table: tableInstance
-        }),
-        models: createModelEntity({
+        }));
+        container.registerInstance(CmsDdbModelEntity, createModelEntity({
             entityName: ENTITIES.MODELS,
             table: tableInstance
-        }),
-        entries: createEntryEntity({
+        }));
+        container.registerInstance(CmsDdbEntryEntity, createEntryEntity({
             entityName: ENTITIES.ENTRIES,
             table: tableInstance
-        })
-    };
-    plugins.register([
-        dynamoDb(),
-        createFilterCreatePlugins()
-    ]);
-    const entries = createEntriesStorageOperations({
-        entity: entities.entries,
-        container,
-        plugins
-    });
-    return {
-        name: "dynamodb",
-        beforeInit: async ()=>{
-            entries.dataLoaders.clearAll();
-        },
-        getEntities: ()=>entities,
-        getTable: ()=>tableInstance,
-        groups: createGroupsStorageOperations({
-            entity: entities.groups,
-            container
-        }),
-        models: createModelsStorageOperations({
-            entity: entities.models
-        }),
-        entries
-    };
-};
-class DynamoDbStorageOperationsFactoryImpl {
-    async create(context) {
-        return createDynamoDbStorageOperations({
-            plugins: context.plugins,
-            container: context.container
-        });
-    }
-}
-const DynamoDbStorageOperationsFactory = StorageOperationsFactory.createImplementation({
-    implementation: DynamoDbStorageOperationsFactoryImpl,
-    dependencies: []
-});
-const storageOperationsFeature = createFeature({
-    name: "cms.storageOperations.openSearch",
-    register: (container)=>{
-        container.register(DynamoDbStorageOperationsFactory).inSingletonScope();
+        }));
+        FilterRegistriesFeature.register(container);
+        DdbGroupStorageOpsFeature.register(container);
+        DdbModelStorageOpsFeature.register(container);
+        DdbEntryStorageOpsFeature.register(container);
     }
 });
-const registerDynamoDbStorageOperations = ()=>{
-    const plugin = createRegisterExtensionPlugin((context)=>storageOperationsFeature.register(context.container));
-    plugin.name = "cms.registerDynamoDbStorageOperations";
-    return [
-        plugin
-    ];
-};
-export { registerDynamoDbStorageOperations };
+export { HeadlessCmsDdbFeature };
 
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import dynamoDbPlugins from \"./dynamoDb/index.js\";\nimport type { CmsContext, StorageOperationsFactory } from \"~/types.js\";\nimport { ENTITIES } from \"~/types.js\";\nimport { createGroupEntity } from \"~/definitions/group.js\";\nimport { createModelEntity } from \"~/definitions/model.js\";\nimport { createEntryEntity } from \"~/definitions/entry.js\";\nimport { createGroupsStorageOperations } from \"~/operations/group/index.js\";\nimport { createModelsStorageOperations } from \"~/operations/model/index.js\";\nimport { createEntriesStorageOperations } from \"./operations/entry/index.js\";\nimport { createFilterCreatePlugins } from \"@webiny/api-headless-cms-storage\";\nimport { createTable } from \"~/definitions/table.js\";\nimport { createRegisterExtensionPlugin } from \"@webiny/handler\";\nimport { createFeature } from \"@webiny/feature/api/index.js\";\nimport { StorageOperationsFactory as StorageOperationsFactoryAbstraction } from \"@webiny/api-headless-cms/exports/api/cms/storage.js\";\nimport { DynamoDBClient } from \"@webiny/db-dynamodb\";\n\nexport * from \"./plugins/index.js\";\n\nconst createDynamoDbStorageOperations: StorageOperationsFactory = params => {\n    const { table, plugins, container } = params;\n\n    const db = container.resolve(DynamoDBClient);\n    const documentClient = db.client;\n\n    const tableInstance = createTable({\n        name: table,\n        documentClient\n    });\n\n    const entities = {\n        groups: createGroupEntity({\n            entityName: ENTITIES.GROUPS,\n            table: tableInstance\n        }),\n        models: createModelEntity({\n            entityName: ENTITIES.MODELS,\n            table: tableInstance\n        }),\n        entries: createEntryEntity({\n            entityName: ENTITIES.ENTRIES,\n            table: tableInstance\n        })\n    };\n\n    plugins.register([\n        /**\n         * Field plugins for DynamoDB.\n         */\n        dynamoDbPlugins(),\n        /**\n         * Filter create plugins.\n         */\n        createFilterCreatePlugins()\n    ]);\n\n    const entries = createEntriesStorageOperations({\n        entity: entities.entries,\n        container,\n        plugins\n    });\n\n    return {\n        name: \"dynamodb\",\n        beforeInit: async () => {\n            entries.dataLoaders.clearAll();\n        },\n        getEntities: () => entities,\n        getTable: () => tableInstance,\n        groups: createGroupsStorageOperations({\n            entity: entities.groups,\n            container\n        }),\n        models: createModelsStorageOperations({\n            entity: entities.models\n        }),\n        entries\n    };\n};\n\nclass DynamoDbStorageOperationsFactoryImpl\n    implements StorageOperationsFactoryAbstraction.Interface\n{\n    public async create(context: CmsContext) {\n        return createDynamoDbStorageOperations({\n            plugins: context.plugins,\n            container: context.container\n        });\n    }\n}\n\nconst DynamoDbStorageOperationsFactory = StorageOperationsFactoryAbstraction.createImplementation({\n    implementation: DynamoDbStorageOperationsFactoryImpl,\n    dependencies: []\n});\n\nconst storageOperationsFeature = createFeature({\n    name: \"cms.storageOperations.openSearch\",\n    register: container => {\n        container.register(DynamoDbStorageOperationsFactory).inSingletonScope();\n    }\n});\n\nexport const registerDynamoDbStorageOperations = () => {\n    const plugin = createRegisterExtensionPlugin(context => {\n        return storageOperationsFeature.register(context.container);\n    });\n    plugin.name = \"cms.registerDynamoDbStorageOperations\";\n\n    return [plugin];\n};\n"],"names":["createDynamoDbStorageOperations","params","table","plugins","container","db","DynamoDBClient","documentClient","tableInstance","createTable","entities","createGroupEntity","ENTITIES","createModelEntity","createEntryEntity","dynamoDbPlugins","createFilterCreatePlugins","entries","createEntriesStorageOperations","createGroupsStorageOperations","createModelsStorageOperations","DynamoDbStorageOperationsFactoryImpl","context","DynamoDbStorageOperationsFactory","StorageOperationsFactoryAbstraction","storageOperationsFeature","createFeature","registerDynamoDbStorageOperations","plugin","createRegisterExtensionPlugin"],"mappings":";;;;;;;;;;;;;;;AAkBA,MAAMA,kCAA4DC,CAAAA;IAC9D,MAAM,EAAEC,KAAK,EAAEC,OAAO,EAAEC,SAAS,EAAE,GAAGH;IAEtC,MAAMI,KAAKD,UAAU,OAAO,CAACE;IAC7B,MAAMC,iBAAiBF,GAAG,MAAM;IAEhC,MAAMG,gBAAgBC,YAAY;QAC9B,MAAMP;QACNK;IACJ;IAEA,MAAMG,WAAW;QACb,QAAQC,kBAAkB;YACtB,YAAYC,SAAS,MAAM;YAC3B,OAAOJ;QACX;QACA,QAAQK,kBAAkB;YACtB,YAAYD,SAAS,MAAM;YAC3B,OAAOJ;QACX;QACA,SAASM,kBAAkB;YACvB,YAAYF,SAAS,OAAO;YAC5B,OAAOJ;QACX;IACJ;IAEAL,QAAQ,QAAQ,CAAC;QAIbY;QAIAC;KACH;IAED,MAAMC,UAAUC,+BAA+B;QAC3C,QAAQR,SAAS,OAAO;QACxBN;QACAD;IACJ;IAEA,OAAO;QACH,MAAM;QACN,YAAY;YACRc,QAAQ,WAAW,CAAC,QAAQ;QAChC;QACA,aAAa,IAAMP;QACnB,UAAU,IAAMF;QAChB,QAAQW,8BAA8B;YAClC,QAAQT,SAAS,MAAM;YACvBN;QACJ;QACA,QAAQgB,8BAA8B;YAClC,QAAQV,SAAS,MAAM;QAC3B;QACAO;IACJ;AACJ;AAEA,MAAMI;IAGF,MAAa,OAAOC,OAAmB,EAAE;QACrC,OAAOtB,gCAAgC;YACnC,SAASsB,QAAQ,OAAO;YACxB,WAAWA,QAAQ,SAAS;QAChC;IACJ;AACJ;AAEA,MAAMC,mCAAmCC,yBAAAA,oBAAwD,CAAC;IAC9F,gBAAgBH;IAChB,cAAc,EAAE;AACpB;AAEA,MAAMI,2BAA2BC,cAAc;IAC3C,MAAM;IACN,UAAUtB,CAAAA;QACNA,UAAU,QAAQ,CAACmB,kCAAkC,gBAAgB;IACzE;AACJ;AAEO,MAAMI,oCAAoC;IAC7C,MAAMC,SAASC,8BAA8BP,CAAAA,UAClCG,yBAAyB,QAAQ,CAACH,QAAQ,SAAS;IAE9DM,OAAO,IAAI,GAAG;IAEd,OAAO;QAACA;KAAO;AACnB"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import { ENTITIES } from \"~/types.js\";\nimport { createGroupEntity } from \"~/definitions/group.js\";\nimport { createModelEntity } from \"~/definitions/model.js\";\nimport { createEntryEntity } from \"~/definitions/entry.js\";\nimport { createTable } from \"~/definitions/table.js\";\nimport { createFeature } from \"@webiny/feature/api/index.js\";\nimport { DynamoDBClient } from \"@webiny/db-dynamodb\";\nimport { FilterUtilFeature } from \"@webiny/db-dynamodb/feature/FilterUtil/feature.js\";\nimport { CmsDdbTable } from \"~/abstractions/CmsDdbTable.js\";\nimport { CmsDdbGroupEntity } from \"~/abstractions/CmsDdbGroupEntity.js\";\nimport { CmsDdbModelEntity } from \"~/abstractions/CmsDdbModelEntity.js\";\nimport { CmsDdbEntryEntity } from \"~/abstractions/CmsDdbEntryEntity.js\";\nimport { FilterRegistriesFeature } from \"@webiny/api-headless-cms-storage\";\nimport { DdbGroupStorageOpsFeature } from \"~/operations/group/feature.js\";\nimport { DdbModelStorageOpsFeature } from \"~/operations/model/feature.js\";\nimport { DdbEntryStorageOpsFeature } from \"~/operations/entry/feature.js\";\n\n/**\n * DynamoDB CMS storage. Register it once, in the root container. Tables and entities are built once\n * per process; the storage operations are transient, and per-request state (the entry DataLoaders,\n * the filter registries) is container scoped, so each request (child) container gets its own.\n * Requires DynamoDBClient to be registered in the container first (via DbFeature).\n */\nexport const HeadlessCmsDdbFeature = createFeature({\n    name: \"cms.storageOperations.ddb\",\n    register: container => {\n        FilterUtilFeature.register(container);\n\n        const db = container.resolve(DynamoDBClient);\n        const documentClient = db.client;\n\n        const tableInstance = createTable({ documentClient });\n\n        // Register infrastructure instances (app-scoped)\n        container.registerInstance(CmsDdbTable, tableInstance);\n        container.registerInstance(\n            CmsDdbGroupEntity,\n            createGroupEntity({\n                entityName: ENTITIES.GROUPS,\n                table: tableInstance\n            })\n        );\n        container.registerInstance(\n            CmsDdbModelEntity,\n            createModelEntity({\n                entityName: ENTITIES.MODELS,\n                table: tableInstance\n            })\n        );\n        container.registerInstance(\n            CmsDdbEntryEntity,\n            createEntryEntity({\n                entityName: ENTITIES.ENTRIES,\n                table: tableInstance\n            })\n        );\n\n        FilterRegistriesFeature.register(container);\n        DdbGroupStorageOpsFeature.register(container);\n        DdbModelStorageOpsFeature.register(container);\n        DdbEntryStorageOpsFeature.register(container);\n    }\n});\n"],"names":["HeadlessCmsDdbFeature","createFeature","container","FilterUtilFeature","db","DynamoDBClient","documentClient","tableInstance","createTable","CmsDdbTable","CmsDdbGroupEntity","createGroupEntity","ENTITIES","CmsDdbModelEntity","createModelEntity","CmsDdbEntryEntity","createEntryEntity","FilterRegistriesFeature","DdbGroupStorageOpsFeature","DdbModelStorageOpsFeature","DdbEntryStorageOpsFeature"],"mappings":";;;;;;;;;;;;;;;;AAuBO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAAUC,CAAAA;QACNC,kBAAkB,QAAQ,CAACD;QAE3B,MAAME,KAAKF,UAAU,OAAO,CAACG;QAC7B,MAAMC,iBAAiBF,GAAG,MAAM;QAEhC,MAAMG,gBAAgBC,YAAY;YAAEF;QAAe;QAGnDJ,UAAU,gBAAgB,CAACO,aAAaF;QACxCL,UAAU,gBAAgB,CACtBQ,mBACAC,kBAAkB;YACd,YAAYC,SAAS,MAAM;YAC3B,OAAOL;QACX;QAEJL,UAAU,gBAAgB,CACtBW,mBACAC,kBAAkB;YACd,YAAYF,SAAS,MAAM;YAC3B,OAAOL;QACX;QAEJL,UAAU,gBAAgB,CACtBa,mBACAC,kBAAkB;YACd,YAAYJ,SAAS,OAAO;YAC5B,OAAOL;QACX;QAGJU,wBAAwB,QAAQ,CAACf;QACjCgB,0BAA0B,QAAQ,CAAChB;QACnCiB,0BAA0B,QAAQ,CAACjB;QACnCkB,0BAA0B,QAAQ,CAAClB;IACvC;AACJ"}

package/operations/entry/DdbCreateEntry.d.ts

@@ -0,0 +1,16 @@
+import type { CmsModel, CmsEntryValues, CmsEntryStorageOperationsCreateParams } from "@webiny/api-headless-cms/types/index.js";
+import { CreateEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js";
+import { CmsDdbEntryEntity } from "../../abstractions/CmsDdbEntryEntity.js";
+import { CmsDdbDataLoaders } from "../../abstractions/CmsDdbDataLoaders.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+declare class DdbCreateEntryImpl implements CreateEntryStorageOperation.Interface {
+    private entity;
+    private dataLoaders;
+    private storageModelProvider;
+    constructor(entity: CmsDdbEntryEntity.Interface, dataLoaders: CmsDdbDataLoaders.Interface, storageModelProvider: CmsStorageModelProvider.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(initialModel: CmsModel, params: CmsEntryStorageOperationsCreateParams<T>): Promise<import("@webiny/api-headless-cms/types/types.js").CmsStorageEntry<T>>;
+}
+export declare const DdbCreateEntry: typeof DdbCreateEntryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js").ICreateEntryStorageOperation>;
+};
+export {};

package/operations/entry/DdbCreateEntry.js

@@ -0,0 +1,77 @@
+import error from "@webiny/error";
+import { CreateEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js";
+import { CmsDdbEntryEntity } from "../../abstractions/CmsDdbEntryEntity.js";
+import { CmsDdbDataLoaders } from "../../abstractions/CmsDdbDataLoaders.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { createEntryLatestKeys, createEntryPublishedKeys, createEntryRevisionKeys } from "./keys.js";
+import { convertToStorageEntry } from "./storageEntryUtils.js";
+class DdbCreateEntryImpl {
+    constructor(entity, dataLoaders, storageModelProvider){
+        this.entity = entity;
+        this.dataLoaders = dataLoaders;
+        this.storageModelProvider = storageModelProvider;
+    }
+    async execute(initialModel, params) {
+        const { entry, storageEntry: initialStorageEntry } = params;
+        const model = this.storageModelProvider.getModel(initialModel);
+        const isPublished = "published" === entry.status;
+        const locked = isPublished ? true : entry.locked;
+        const storageEntry = convertToStorageEntry({
+            model,
+            storageEntry: initialStorageEntry
+        });
+        const storageEntryRevisionKeys = createEntryRevisionKeys(entry);
+        const storageEntryLatestKeys = createEntryLatestKeys(entry);
+        const entityBatch = this.entity.createEntityWriter({
+            put: [
+                {
+                    ...storageEntryRevisionKeys,
+                    data: {
+                        ...storageEntry,
+                        locked
+                    }
+                },
+                {
+                    ...storageEntryLatestKeys,
+                    data: {
+                        ...storageEntry,
+                        locked
+                    }
+                }
+            ]
+        });
+        if (isPublished) {
+            const storageEntryPublishedKeys = createEntryPublishedKeys(storageEntry);
+            entityBatch.put({
+                ...storageEntryPublishedKeys,
+                data: {
+                    ...storageEntry,
+                    locked
+                }
+            });
+        }
+        try {
+            await entityBatch.execute();
+            this.dataLoaders.clearAll({
+                tenant: entry.tenant
+            });
+        } catch (ex) {
+            throw new error(ex.message || "Could not insert data into the DynamoDB.", ex.code || "CREATE_ENTRY_ERROR", {
+                error: ex,
+                entry
+            });
+        }
+        return initialStorageEntry;
+    }
+}
+const DdbCreateEntry = CreateEntryStorageOperation.createImplementation({
+    implementation: DdbCreateEntryImpl,
+    dependencies: [
+        CmsDdbEntryEntity,
+        CmsDdbDataLoaders,
+        CmsStorageModelProvider
+    ]
+});
+export { DdbCreateEntry };
+
+//# sourceMappingURL=DdbCreateEntry.js.map

package/operations/entry/DdbCreateEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/DdbCreateEntry.js","sources":["../../../src/operations/entry/DdbCreateEntry.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type {\n    CmsModel,\n    CmsEntryValues,\n    CmsEntryStorageOperationsCreateParams\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { CreateEntryStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js\";\nimport { CmsDdbEntryEntity } from \"~/abstractions/CmsDdbEntryEntity.js\";\nimport { CmsDdbDataLoaders } from \"~/abstractions/CmsDdbDataLoaders.js\";\nimport { CmsStorageModelProvider } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport {\n    createEntryLatestKeys,\n    createEntryPublishedKeys,\n    createEntryRevisionKeys\n} from \"~/operations/entry/keys.js\";\nimport { convertToStorageEntry } from \"./storageEntryUtils.js\";\n\nclass DdbCreateEntryImpl implements CreateEntryStorageOperation.Interface {\n    constructor(\n        private entity: CmsDdbEntryEntity.Interface,\n        private dataLoaders: CmsDdbDataLoaders.Interface,\n        private storageModelProvider: CmsStorageModelProvider.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues = CmsEntryValues>(\n        initialModel: CmsModel,\n        params: CmsEntryStorageOperationsCreateParams<T>\n    ) {\n        const { entry, storageEntry: initialStorageEntry } = params;\n        const model = this.storageModelProvider.getModel(initialModel);\n\n        const isPublished = entry.status === \"published\";\n\n        const locked = isPublished ? true : entry.locked;\n\n        const storageEntry = convertToStorageEntry({\n            model,\n            storageEntry: initialStorageEntry\n        });\n\n        const storageEntryRevisionKeys = createEntryRevisionKeys(entry);\n        const storageEntryLatestKeys = createEntryLatestKeys(entry);\n        /**\n         * We need to:\n         *  - create new main entry item\n         *  - create new or update the latest entry item\n         */\n        const entityBatch = this.entity.createEntityWriter({\n            put: [\n                {\n                    ...storageEntryRevisionKeys,\n                    data: {\n                        ...storageEntry,\n                        locked\n                    }\n                },\n                {\n                    ...storageEntryLatestKeys,\n                    data: {\n                        ...storageEntry,\n                        locked\n                    }\n                }\n            ]\n        });\n\n        /**\n         * We need to create published entry if\n         */\n        if (isPublished) {\n            const storageEntryPublishedKeys = createEntryPublishedKeys(storageEntry);\n            entityBatch.put({\n                ...storageEntryPublishedKeys,\n                data: {\n                    ...storageEntry,\n                    locked\n                }\n            });\n        }\n\n        try {\n            await entityBatch.execute();\n            this.dataLoaders.clearAll({\n                tenant: entry.tenant\n            });\n        } catch (ex) {\n            throw new WebinyError(\n                ex.message || \"Could not insert data into the DynamoDB.\",\n                ex.code || \"CREATE_ENTRY_ERROR\",\n                {\n                    error: ex,\n                    entry\n                }\n            );\n        }\n\n        return initialStorageEntry;\n    }\n}\n\nexport const DdbCreateEntry = CreateEntryStorageOperation.createImplementation({\n    implementation: DdbCreateEntryImpl,\n    dependencies: [CmsDdbEntryEntity, CmsDdbDataLoaders, CmsStorageModelProvider]\n});\n"],"names":["DdbCreateEntryImpl","entity","dataLoaders","storageModelProvider","initialModel","params","entry","initialStorageEntry","model","isPublished","locked","storageEntry","convertToStorageEntry","storageEntryRevisionKeys","createEntryRevisionKeys","storageEntryLatestKeys","createEntryLatestKeys","entityBatch","storageEntryPublishedKeys","createEntryPublishedKeys","ex","WebinyError","DdbCreateEntry","CreateEntryStorageOperation","CmsDdbEntryEntity","CmsDdbDataLoaders","CmsStorageModelProvider"],"mappings":";;;;;;;AAiBA,MAAMA;IACF,YACYC,MAAmC,EACnCC,WAAwC,EACxCC,oBAAuD,CACjE;aAHUF,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,oBAAoB,GAApBA;IACT;IAEH,MAAM,QACFC,YAAsB,EACtBC,MAAgD,EAClD;QACE,MAAM,EAAEC,KAAK,EAAE,cAAcC,mBAAmB,EAAE,GAAGF;QACrD,MAAMG,QAAQ,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAACJ;QAEjD,MAAMK,cAAcH,AAAiB,gBAAjBA,MAAM,MAAM;QAEhC,MAAMI,SAASD,cAAc,OAAOH,MAAM,MAAM;QAEhD,MAAMK,eAAeC,sBAAsB;YACvCJ;YACA,cAAcD;QAClB;QAEA,MAAMM,2BAA2BC,wBAAwBR;QACzD,MAAMS,yBAAyBC,sBAAsBV;QAMrD,MAAMW,cAAc,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC;YAC/C,KAAK;gBACD;oBACI,GAAGJ,wBAAwB;oBAC3B,MAAM;wBACF,GAAGF,YAAY;wBACfD;oBACJ;gBACJ;gBACA;oBACI,GAAGK,sBAAsB;oBACzB,MAAM;wBACF,GAAGJ,YAAY;wBACfD;oBACJ;gBACJ;aACH;QACL;QAKA,IAAID,aAAa;YACb,MAAMS,4BAA4BC,yBAAyBR;YAC3DM,YAAY,GAAG,CAAC;gBACZ,GAAGC,yBAAyB;gBAC5B,MAAM;oBACF,GAAGP,YAAY;oBACfD;gBACJ;YACJ;QACJ;QAEA,IAAI;YACA,MAAMO,YAAY,OAAO;YACzB,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;gBACtB,QAAQX,MAAM,MAAM;YACxB;QACJ,EAAE,OAAOc,IAAI;YACT,MAAM,IAAIC,MACND,GAAG,OAAO,IAAI,4CACdA,GAAG,IAAI,IAAI,sBACX;gBACI,OAAOA;gBACPd;YACJ;QAER;QAEA,OAAOC;IACX;AACJ;AAEO,MAAMe,iBAAiBC,4BAA4B,oBAAoB,CAAC;IAC3E,gBAAgBvB;IAChB,cAAc;QAACwB;QAAmBC;QAAmBC;KAAwB;AACjF"}

package/operations/entry/DdbCreateEntryRevisionFrom.d.ts

@@ -0,0 +1,16 @@
+import type { CmsModel, CmsEntryValues, CmsEntryStorageOperationsCreateRevisionFromParams } from "@webiny/api-headless-cms/types/index.js";
+import { CreateEntryRevisionFromStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js";
+import { CmsDdbEntryEntity } from "../../abstractions/CmsDdbEntryEntity.js";
+import { CmsDdbDataLoaders } from "../../abstractions/CmsDdbDataLoaders.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+declare class DdbCreateEntryRevisionFromImpl implements CreateEntryRevisionFromStorageOperation.Interface {
+    private entity;
+    private dataLoaders;
+    private storageModelProvider;
+    constructor(entity: CmsDdbEntryEntity.Interface, dataLoaders: CmsDdbDataLoaders.Interface, storageModelProvider: CmsStorageModelProvider.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(initialModel: CmsModel, params: CmsEntryStorageOperationsCreateRevisionFromParams<T>): Promise<import("@webiny/api-headless-cms/types/types.js").CmsStorageEntry<T>>;
+}
+export declare const DdbCreateEntryRevisionFrom: typeof DdbCreateEntryRevisionFromImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js").ICreateEntryRevisionFromStorageOperation>;
+};
+export {};

package/operations/entry/DdbCreateEntryRevisionFrom.js

@@ -0,0 +1,85 @@
+import error from "@webiny/error";
+import { CONTENT_ENTRY_STATUS } from "@webiny/api-headless-cms/types/index.js";
+import { CreateEntryRevisionFromStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js";
+import { CmsDdbEntryEntity } from "../../abstractions/CmsDdbEntryEntity.js";
+import { CmsDdbDataLoaders } from "../../abstractions/CmsDdbDataLoaders.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { createEntryLatestKeys, createEntryPublishedKeys, createEntryRevisionKeys } from "./keys.js";
+import { convertToStorageEntry } from "./storageEntryUtils.js";
+class DdbCreateEntryRevisionFromImpl {
+    constructor(entity, dataLoaders, storageModelProvider){
+        this.entity = entity;
+        this.dataLoaders = dataLoaders;
+        this.storageModelProvider = storageModelProvider;
+    }
+    async execute(initialModel, params) {
+        const { entry, storageEntry: initialStorageEntry } = params;
+        const model = this.storageModelProvider.getModel(initialModel);
+        const storageEntry = convertToStorageEntry({
+            storageEntry: initialStorageEntry,
+            model
+        });
+        const entityBatch = this.entity.createEntityWriter({
+            put: [
+                {
+                    ...createEntryRevisionKeys(storageEntry),
+                    data: {
+                        ...storageEntry
+                    }
+                },
+                {
+                    ...createEntryLatestKeys(storageEntry),
+                    data: {
+                        ...storageEntry
+                    }
+                }
+            ]
+        });
+        const isPublished = "published" === entry.status;
+        if (isPublished) {
+            entityBatch.put({
+                ...createEntryPublishedKeys(storageEntry),
+                data: {
+                    ...storageEntry
+                }
+            });
+            const [publishedRevisionStorageEntry] = await this.dataLoaders.getPublishedRevisionByEntryId({
+                model,
+                ids: [
+                    entry.id
+                ]
+            });
+            if (publishedRevisionStorageEntry) entityBatch.put({
+                ...createEntryRevisionKeys(publishedRevisionStorageEntry),
+                data: {
+                    ...publishedRevisionStorageEntry,
+                    status: CONTENT_ENTRY_STATUS.UNPUBLISHED
+                }
+            });
+        }
+        try {
+            await entityBatch.execute();
+            this.dataLoaders.clearAll({
+                tenant: entry.tenant
+            });
+        } catch (ex) {
+            throw new error(ex.message || "Could not create revision from given entry.", ex.code || "CREATE_REVISION_ERROR", {
+                error: ex,
+                entry,
+                storageEntry
+            });
+        }
+        return initialStorageEntry;
+    }
+}
+const DdbCreateEntryRevisionFrom = CreateEntryRevisionFromStorageOperation.createImplementation({
+    implementation: DdbCreateEntryRevisionFromImpl,
+    dependencies: [
+        CmsDdbEntryEntity,
+        CmsDdbDataLoaders,
+        CmsStorageModelProvider
+    ]
+});
+export { DdbCreateEntryRevisionFrom };
+
+//# sourceMappingURL=DdbCreateEntryRevisionFrom.js.map

package/operations/entry/DdbCreateEntryRevisionFrom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/DdbCreateEntryRevisionFrom.js","sources":["../../../src/operations/entry/DdbCreateEntryRevisionFrom.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type {\n    CmsModel,\n    CmsEntryValues,\n    CmsEntryStorageOperationsCreateRevisionFromParams\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { CONTENT_ENTRY_STATUS } from \"@webiny/api-headless-cms/types/index.js\";\nimport { CreateEntryRevisionFromStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js\";\nimport { CmsDdbEntryEntity } from \"~/abstractions/CmsDdbEntryEntity.js\";\nimport { CmsDdbDataLoaders } from \"~/abstractions/CmsDdbDataLoaders.js\";\nimport { CmsStorageModelProvider } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport {\n    createEntryLatestKeys,\n    createEntryPublishedKeys,\n    createEntryRevisionKeys\n} from \"~/operations/entry/keys.js\";\nimport { convertToStorageEntry } from \"./storageEntryUtils.js\";\n\nclass DdbCreateEntryRevisionFromImpl implements CreateEntryRevisionFromStorageOperation.Interface {\n    constructor(\n        private entity: CmsDdbEntryEntity.Interface,\n        private dataLoaders: CmsDdbDataLoaders.Interface,\n        private storageModelProvider: CmsStorageModelProvider.Interface\n    ) {}\n\n    async execute<T extends CmsEntryValues = CmsEntryValues>(\n        initialModel: CmsModel,\n        params: CmsEntryStorageOperationsCreateRevisionFromParams<T>\n    ) {\n        const { entry, storageEntry: initialStorageEntry } = params;\n        const model = this.storageModelProvider.getModel(initialModel);\n\n        const storageEntry = convertToStorageEntry({\n            storageEntry: initialStorageEntry,\n            model\n        });\n\n        /**\n         * We need to:\n         *  - create the main entry item\n         *  - update the latest entry item to the current one\n         *  - if the entry's status was set to \"published\":\n         *      - update the published entry item to the current one\n         *      - unpublish previously published revision (if any)\n         */\n        const entityBatch = this.entity.createEntityWriter({\n            put: [\n                {\n                    ...createEntryRevisionKeys(storageEntry),\n                    data: {\n                        ...storageEntry\n                    }\n                },\n                {\n                    ...createEntryLatestKeys(storageEntry),\n                    data: {\n                        ...storageEntry\n                    }\n                }\n            ]\n        });\n\n        const isPublished = entry.status === \"published\";\n        if (isPublished) {\n            entityBatch.put({\n                ...createEntryPublishedKeys(storageEntry),\n                data: {\n                    ...storageEntry\n                }\n            });\n\n            // Unpublish previously published revision (if any).\n            const [publishedRevisionStorageEntry] =\n                await this.dataLoaders.getPublishedRevisionByEntryId({\n                    model,\n                    ids: [entry.id]\n                });\n\n            if (publishedRevisionStorageEntry) {\n                entityBatch.put({\n                    ...createEntryRevisionKeys(publishedRevisionStorageEntry),\n                    data: {\n                        ...publishedRevisionStorageEntry,\n                        status: CONTENT_ENTRY_STATUS.UNPUBLISHED\n                    }\n                });\n            }\n        }\n\n        try {\n            await entityBatch.execute();\n            this.dataLoaders.clearAll({\n                tenant: entry.tenant\n            });\n        } catch (ex) {\n            throw new WebinyError(\n                ex.message || \"Could not create revision from given entry.\",\n                ex.code || \"CREATE_REVISION_ERROR\",\n                {\n                    error: ex,\n                    entry,\n                    storageEntry\n                }\n            );\n        }\n        /**\n         * There are no modifications on the entry created so just return the data.\n         */\n        return initialStorageEntry;\n    }\n}\n\nexport const DdbCreateEntryRevisionFrom =\n    CreateEntryRevisionFromStorageOperation.createImplementation({\n        implementation: DdbCreateEntryRevisionFromImpl,\n        dependencies: [CmsDdbEntryEntity, CmsDdbDataLoaders, CmsStorageModelProvider]\n    });\n"],"names":["DdbCreateEntryRevisionFromImpl","entity","dataLoaders","storageModelProvider","initialModel","params","entry","initialStorageEntry","model","storageEntry","convertToStorageEntry","entityBatch","createEntryRevisionKeys","createEntryLatestKeys","isPublished","createEntryPublishedKeys","publishedRevisionStorageEntry","CONTENT_ENTRY_STATUS","ex","WebinyError","DdbCreateEntryRevisionFrom","CreateEntryRevisionFromStorageOperation","CmsDdbEntryEntity","CmsDdbDataLoaders","CmsStorageModelProvider"],"mappings":";;;;;;;;AAkBA,MAAMA;IACF,YACYC,MAAmC,EACnCC,WAAwC,EACxCC,oBAAuD,CACjE;aAHUF,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,oBAAoB,GAApBA;IACT;IAEH,MAAM,QACFC,YAAsB,EACtBC,MAA4D,EAC9D;QACE,MAAM,EAAEC,KAAK,EAAE,cAAcC,mBAAmB,EAAE,GAAGF;QACrD,MAAMG,QAAQ,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAACJ;QAEjD,MAAMK,eAAeC,sBAAsB;YACvC,cAAcH;YACdC;QACJ;QAUA,MAAMG,cAAc,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC;YAC/C,KAAK;gBACD;oBACI,GAAGC,wBAAwBH,aAAa;oBACxC,MAAM;wBACF,GAAGA,YAAY;oBACnB;gBACJ;gBACA;oBACI,GAAGI,sBAAsBJ,aAAa;oBACtC,MAAM;wBACF,GAAGA,YAAY;oBACnB;gBACJ;aACH;QACL;QAEA,MAAMK,cAAcR,AAAiB,gBAAjBA,MAAM,MAAM;QAChC,IAAIQ,aAAa;YACbH,YAAY,GAAG,CAAC;gBACZ,GAAGI,yBAAyBN,aAAa;gBACzC,MAAM;oBACF,GAAGA,YAAY;gBACnB;YACJ;YAGA,MAAM,CAACO,8BAA8B,GACjC,MAAM,IAAI,CAAC,WAAW,CAAC,6BAA6B,CAAC;gBACjDR;gBACA,KAAK;oBAACF,MAAM,EAAE;iBAAC;YACnB;YAEJ,IAAIU,+BACAL,YAAY,GAAG,CAAC;gBACZ,GAAGC,wBAAwBI,8BAA8B;gBACzD,MAAM;oBACF,GAAGA,6BAA6B;oBAChC,QAAQC,qBAAqB,WAAW;gBAC5C;YACJ;QAER;QAEA,IAAI;YACA,MAAMN,YAAY,OAAO;YACzB,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;gBACtB,QAAQL,MAAM,MAAM;YACxB;QACJ,EAAE,OAAOY,IAAI;YACT,MAAM,IAAIC,MACND,GAAG,OAAO,IAAI,+CACdA,GAAG,IAAI,IAAI,yBACX;gBACI,OAAOA;gBACPZ;gBACAG;YACJ;QAER;QAIA,OAAOF;IACX;AACJ;AAEO,MAAMa,6BACTC,wCAAwC,oBAAoB,CAAC;IACzD,gBAAgBrB;IAChB,cAAc;QAACsB;QAAmBC;QAAmBC;KAAwB;AACjF"}

package/operations/entry/DdbDeleteEntry.d.ts

@@ -0,0 +1,16 @@
+import type { CmsModel, CmsEntryStorageOperationsDeleteParams } from "@webiny/api-headless-cms/types/index.js";
+import { DeleteEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js";
+import { CmsDdbEntryEntity } from "../../abstractions/CmsDdbEntryEntity.js";
+import { CmsDdbDataLoaders } from "../../abstractions/CmsDdbDataLoaders.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+declare class DdbDeleteEntryImpl implements DeleteEntryStorageOperation.Interface {
+    private entity;
+    private dataLoaders;
+    private storageModelProvider;
+    constructor(entity: CmsDdbEntryEntity.Interface, dataLoaders: CmsDdbDataLoaders.Interface, storageModelProvider: CmsStorageModelProvider.Interface);
+    execute(initialModel: CmsModel, params: CmsEntryStorageOperationsDeleteParams): Promise<void>;
+}
+export declare const DdbDeleteEntry: typeof DdbDeleteEntryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js").IDeleteEntryStorageOperation>;
+};
+export {};

package/operations/entry/DdbDeleteEntry.js

@@ -0,0 +1,65 @@
+import error from "@webiny/error";
+import { DeleteEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js";
+import { CmsDdbEntryEntity } from "../../abstractions/CmsDdbEntryEntity.js";
+import { CmsDdbDataLoaders } from "../../abstractions/CmsDdbDataLoaders.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { createPartitionKey } from "./keys.js";
+class DdbDeleteEntryImpl {
+    constructor(entity, dataLoaders, storageModelProvider){
+        this.entity = entity;
+        this.dataLoaders = dataLoaders;
+        this.storageModelProvider = storageModelProvider;
+    }
+    async execute(initialModel, params) {
+        const { entry } = params;
+        const id = entry.id || entry.entryId;
+        const model = this.storageModelProvider.getModel(initialModel);
+        const partitionKey = createPartitionKey({
+            id,
+            tenant: model.tenant
+        });
+        let records = [];
+        try {
+            records = await this.entity.queryAll({
+                partitionKey,
+                options: {
+                    gte: " "
+                }
+            });
+        } catch (ex) {
+            throw new error(ex.message || "Could not load all records.", ex.code || "LOAD_ALL_RECORDS_ERROR", {
+                error: ex,
+                id
+            });
+        }
+        const entityBatch = this.entity.createEntityWriter({
+            delete: records.map((item)=>({
+                    PK: item.PK,
+                    SK: item.SK
+                }))
+        });
+        try {
+            await entityBatch.execute();
+            this.dataLoaders.clearAll({
+                tenant: entry.tenant
+            });
+        } catch (ex) {
+            throw new error(ex.message || "Could not delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
+                error: ex,
+                partitionKey,
+                id
+            });
+        }
+    }
+}
+const DdbDeleteEntry = DeleteEntryStorageOperation.createImplementation({
+    implementation: DdbDeleteEntryImpl,
+    dependencies: [
+        CmsDdbEntryEntity,
+        CmsDdbDataLoaders,
+        CmsStorageModelProvider
+    ]
+});
+export { DdbDeleteEntry };
+
+//# sourceMappingURL=DdbDeleteEntry.js.map

package/operations/entry/DdbDeleteEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/DdbDeleteEntry.js","sources":["../../../src/operations/entry/DdbDeleteEntry.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport type {\n    CmsModel,\n    CmsEntryStorageOperationsDeleteParams\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { DeleteEntryStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js\";\nimport { CmsDdbEntryEntity } from \"~/abstractions/CmsDdbEntryEntity.js\";\nimport { CmsDdbDataLoaders } from \"~/abstractions/CmsDdbDataLoaders.js\";\nimport { CmsStorageModelProvider } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport { createPartitionKey } from \"~/operations/entry/keys.js\";\n\nclass DdbDeleteEntryImpl implements DeleteEntryStorageOperation.Interface {\n    constructor(\n        private entity: CmsDdbEntryEntity.Interface,\n        private dataLoaders: CmsDdbDataLoaders.Interface,\n        private storageModelProvider: CmsStorageModelProvider.Interface\n    ) {}\n\n    async execute(initialModel: CmsModel, params: CmsEntryStorageOperationsDeleteParams) {\n        const { entry } = params;\n        const id = entry.id || entry.entryId;\n        const model = this.storageModelProvider.getModel(initialModel);\n\n        const partitionKey = createPartitionKey({\n            id,\n            tenant: model.tenant\n        });\n\n        let records: Awaited<ReturnType<typeof this.entity.queryAll>> = [];\n        try {\n            records = await this.entity.queryAll({\n                partitionKey,\n                options: {\n                    gte: \" \"\n                }\n            });\n        } catch (ex) {\n            throw new WebinyError(\n                ex.message || \"Could not load all records.\",\n                ex.code || \"LOAD_ALL_RECORDS_ERROR\",\n                {\n                    error: ex,\n                    id\n                }\n            );\n        }\n\n        const entityBatch = this.entity.createEntityWriter({\n            delete: records.map(item => {\n                return {\n                    PK: item.PK,\n                    SK: item.SK\n                };\n            })\n        });\n\n        try {\n            await entityBatch.execute();\n            this.dataLoaders.clearAll({\n                tenant: entry.tenant\n            });\n        } catch (ex) {\n            throw new WebinyError(\n                ex.message || \"Could not delete the entry.\",\n                ex.code || \"DELETE_ENTRY_ERROR\",\n                {\n                    error: ex,\n                    partitionKey,\n                    id\n                }\n            );\n        }\n    }\n}\n\nexport const DdbDeleteEntry = DeleteEntryStorageOperation.createImplementation({\n    implementation: DdbDeleteEntryImpl,\n    dependencies: [CmsDdbEntryEntity, CmsDdbDataLoaders, CmsStorageModelProvider]\n});\n"],"names":["DdbDeleteEntryImpl","entity","dataLoaders","storageModelProvider","initialModel","params","entry","id","model","partitionKey","createPartitionKey","records","ex","WebinyError","entityBatch","item","DdbDeleteEntry","DeleteEntryStorageOperation","CmsDdbEntryEntity","CmsDdbDataLoaders","CmsStorageModelProvider"],"mappings":";;;;;;AAWA,MAAMA;IACF,YACYC,MAAmC,EACnCC,WAAwC,EACxCC,oBAAuD,CACjE;aAHUF,MAAM,GAANA;aACAC,WAAW,GAAXA;aACAC,oBAAoB,GAApBA;IACT;IAEH,MAAM,QAAQC,YAAsB,EAAEC,MAA6C,EAAE;QACjF,MAAM,EAAEC,KAAK,EAAE,GAAGD;QAClB,MAAME,KAAKD,MAAM,EAAE,IAAIA,MAAM,OAAO;QACpC,MAAME,QAAQ,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAACJ;QAEjD,MAAMK,eAAeC,mBAAmB;YACpCH;YACA,QAAQC,MAAM,MAAM;QACxB;QAEA,IAAIG,UAA4D,EAAE;QAClE,IAAI;YACAA,UAAU,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;gBACjCF;gBACA,SAAS;oBACL,KAAK;gBACT;YACJ;QACJ,EAAE,OAAOG,IAAI;YACT,MAAM,IAAIC,MACND,GAAG,OAAO,IAAI,+BACdA,GAAG,IAAI,IAAI,0BACX;gBACI,OAAOA;gBACPL;YACJ;QAER;QAEA,MAAMO,cAAc,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC;YAC/C,QAAQH,QAAQ,GAAG,CAACI,CAAAA,OACT;oBACH,IAAIA,KAAK,EAAE;oBACX,IAAIA,KAAK,EAAE;gBACf;QAER;QAEA,IAAI;YACA,MAAMD,YAAY,OAAO;YACzB,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC;gBACtB,QAAQR,MAAM,MAAM;YACxB;QACJ,EAAE,OAAOM,IAAI;YACT,MAAM,IAAIC,MACND,GAAG,OAAO,IAAI,+BACdA,GAAG,IAAI,IAAI,sBACX;gBACI,OAAOA;gBACPH;gBACAF;YACJ;QAER;IACJ;AACJ;AAEO,MAAMS,iBAAiBC,4BAA4B,oBAAoB,CAAC;IAC3E,gBAAgBjB;IAChB,cAAc;QAACkB;QAAmBC;QAAmBC;KAAwB;AACjF"}

package/operations/entry/DdbDeleteEntryRevision.d.ts

@@ -0,0 +1,17 @@
+import type { CmsModel, CmsEntryValues, CmsEntryStorageOperationsDeleteRevisionParams } from "@webiny/api-headless-cms/types/index.js";
+import { DeleteEntryRevisionStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryRevisionStorageOperation.js";
+import { CmsDdbEntryEntity } from "../../abstractions/CmsDdbEntryEntity.js";
+import { CmsDdbDataLoaders } from "../../abstractions/CmsDdbDataLoaders.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+declare class DdbDeleteEntryRevisionImpl implements DeleteEntryRevisionStorageOperation.Interface {
+    private entity;
+    private dataLoaders;
+    private storageModelProvider;
+    constructor(entity: CmsDdbEntryEntity.Interface, dataLoaders: CmsDdbDataLoaders.Interface, storageModelProvider: CmsStorageModelProvider.Interface);
+    private getPublishedRevisionByEntryId;
+    execute<T extends CmsEntryValues = CmsEntryValues>(initialModel: CmsModel, params: CmsEntryStorageOperationsDeleteRevisionParams<T>): Promise<void>;
+}
+export declare const DdbDeleteEntryRevision: typeof DdbDeleteEntryRevisionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryRevisionStorageOperation.js").IDeleteEntryRevisionStorageOperation>;
+};
+export {};