@webiny/api-headless-cms-pg-os 6.6.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-headless-cms-pg-os
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/features/HeadlessCmsPgOsFeature.d.ts

@@ -0,0 +1,9 @@
+export interface IPgOsStorageOperationsConfig {
+    knex: any;
+    tableNamePrefix?: string;
+    tableNameSuffix?: string;
+}
+export declare const HeadlessCmsPgOsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container, context: IPgOsStorageOperationsConfig): void;
+};

package/features/HeadlessCmsPgOsFeature.js

@@ -0,0 +1,40 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { CmsEntryOpenSearchUtilsFeature } from "@webiny/api-headless-cms-utils-os";
+import { TableNameResolverConfig } from "@webiny/api-headless-cms-sql/features/tableNameResolver/abstractions.js";
+import { TableNameResolverFeature } from "@webiny/api-headless-cms-sql/features/tableNameResolver/feature.js";
+import { ValueFilterFeature } from "@webiny/db-utils";
+import { GroupSchemaManagerFeature } from "@webiny/api-headless-cms-sql/features/groupSchemaManager/feature.js";
+import { ModelSchemaManagerFeature } from "@webiny/api-headless-cms-sql/features/modelSchemaManager/feature.js";
+import { EntryTableManagerFeature } from "@webiny/api-headless-cms-sql/features/entryTableManager/feature.js";
+import { SyncTableManagerFeature } from "./syncTableManager/feature.js";
+import { SyncWriterFeature } from "./SyncWriter/feature.js";
+import { FilterRegistriesFeature } from "@webiny/api-headless-cms-storage";
+import { SqlGroupStorageOpsFeature } from "@webiny/api-headless-cms-sql/operations/group/feature.js";
+import { SqlModelStorageOpsFeature } from "@webiny/api-headless-cms-sql/operations/model/feature.js";
+import { PgOsEntryStorageOpsFeature } from "../operations/entry/feature.js";
+const HeadlessCmsPgOsFeature = createFeature({
+    name: "cms.storageOperations.pgOs",
+    register: (container, config)=>{
+        const sharedTables = "true" === process.env.WEBINY_SHARED_TABLES;
+        container.registerInstance(TableNameResolverConfig, {
+            sharedTables,
+            tableNamePrefix: config.tableNamePrefix,
+            tableNameSuffix: config.tableNameSuffix
+        });
+        TableNameResolverFeature.register(container);
+        ValueFilterFeature.register(container);
+        FilterRegistriesFeature.register(container);
+        GroupSchemaManagerFeature.register(container);
+        ModelSchemaManagerFeature.register(container);
+        EntryTableManagerFeature.register(container);
+        SyncTableManagerFeature.register(container);
+        SyncWriterFeature.register(container);
+        CmsEntryOpenSearchUtilsFeature.register(container);
+        SqlGroupStorageOpsFeature.register(container);
+        SqlModelStorageOpsFeature.register(container);
+        PgOsEntryStorageOpsFeature.register(container);
+    }
+});
+export { HeadlessCmsPgOsFeature };
+
+//# sourceMappingURL=HeadlessCmsPgOsFeature.js.map

package/features/HeadlessCmsPgOsFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/HeadlessCmsPgOsFeature.js","sources":["../../src/features/HeadlessCmsPgOsFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { CmsEntryOpenSearchUtilsFeature } from \"@webiny/api-headless-cms-utils-os\";\nimport { TableNameResolverConfig } from \"@webiny/api-headless-cms-sql/features/tableNameResolver/abstractions.js\";\nimport { TableNameResolverFeature } from \"@webiny/api-headless-cms-sql/features/tableNameResolver/feature.js\";\nimport { ValueFilterFeature } from \"@webiny/db-utils\";\nimport { GroupSchemaManagerFeature } from \"@webiny/api-headless-cms-sql/features/groupSchemaManager/feature.js\";\nimport { ModelSchemaManagerFeature } from \"@webiny/api-headless-cms-sql/features/modelSchemaManager/feature.js\";\nimport { EntryTableManagerFeature } from \"@webiny/api-headless-cms-sql/features/entryTableManager/feature.js\";\nimport { SyncTableManagerFeature } from \"./syncTableManager/feature.js\";\nimport { SyncWriterFeature } from \"./SyncWriter/feature.js\";\nimport { FilterRegistriesFeature } from \"@webiny/api-headless-cms-storage\";\nimport { SqlGroupStorageOpsFeature } from \"@webiny/api-headless-cms-sql/operations/group/feature.js\";\nimport { SqlModelStorageOpsFeature } from \"@webiny/api-headless-cms-sql/operations/model/feature.js\";\nimport { PgOsEntryStorageOpsFeature } from \"~/operations/entry/feature.js\";\n\nexport interface IPgOsStorageOperationsConfig {\n    knex: any;\n    tableNamePrefix?: string;\n    tableNameSuffix?: string;\n}\n\nexport const HeadlessCmsPgOsFeature = createFeature<IPgOsStorageOperationsConfig>({\n    name: \"cms.storageOperations.pgOs\",\n    register: (container, config) => {\n        const sharedTables = process.env.WEBINY_SHARED_TABLES === \"true\";\n\n        container.registerInstance(TableNameResolverConfig, {\n            sharedTables,\n            tableNamePrefix: config.tableNamePrefix,\n            tableNameSuffix: config.tableNameSuffix\n        });\n\n        TableNameResolverFeature.register(container);\n        ValueFilterFeature.register(container);\n        FilterRegistriesFeature.register(container);\n        GroupSchemaManagerFeature.register(container);\n        ModelSchemaManagerFeature.register(container);\n        EntryTableManagerFeature.register(container);\n        SyncTableManagerFeature.register(container);\n        SyncWriterFeature.register(container);\n\n        CmsEntryOpenSearchUtilsFeature.register(container);\n\n        SqlGroupStorageOpsFeature.register(container);\n        SqlModelStorageOpsFeature.register(container);\n\n        PgOsEntryStorageOpsFeature.register(container);\n    }\n});\n"],"names":["HeadlessCmsPgOsFeature","createFeature","container","config","sharedTables","process","TableNameResolverConfig","TableNameResolverFeature","ValueFilterFeature","FilterRegistriesFeature","GroupSchemaManagerFeature","ModelSchemaManagerFeature","EntryTableManagerFeature","SyncTableManagerFeature","SyncWriterFeature","CmsEntryOpenSearchUtilsFeature","SqlGroupStorageOpsFeature","SqlModelStorageOpsFeature","PgOsEntryStorageOpsFeature"],"mappings":";;;;;;;;;;;;;;AAqBO,MAAMA,yBAAyBC,cAA4C;IAC9E,MAAM;IACN,UAAU,CAACC,WAAWC;QAClB,MAAMC,eAAeC,AAAqC,WAArCA,QAAQ,GAAG,CAAC,oBAAoB;QAErDH,UAAU,gBAAgB,CAACI,yBAAyB;YAChDF;YACA,iBAAiBD,OAAO,eAAe;YACvC,iBAAiBA,OAAO,eAAe;QAC3C;QAEAI,yBAAyB,QAAQ,CAACL;QAClCM,mBAAmB,QAAQ,CAACN;QAC5BO,wBAAwB,QAAQ,CAACP;QACjCQ,0BAA0B,QAAQ,CAACR;QACnCS,0BAA0B,QAAQ,CAACT;QACnCU,yBAAyB,QAAQ,CAACV;QAClCW,wBAAwB,QAAQ,CAACX;QACjCY,kBAAkB,QAAQ,CAACZ;QAE3Ba,+BAA+B,QAAQ,CAACb;QAExCc,0BAA0B,QAAQ,CAACd;QACnCe,0BAA0B,QAAQ,CAACf;QAEnCgB,2BAA2B,QAAQ,CAAChB;IACxC;AACJ"}

package/features/SyncWriter/BuildSyncRecord.d.ts

@@ -0,0 +1,22 @@
+import type { CmsEntryValues } from "@webiny/api-headless-cms/types/index.js";
+import { BuildSyncRecord as Abstraction } from "./abstractions/BuildSyncRecord.js";
+import { CmsEntryOpenSearchFieldIndexRegistry } from "@webiny/api-headless-cms-utils-os/exports/api/cms/opensearch.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+import { OperationType } from "@webiny/api-sync-to-opensearch/features/Operations/Operations.js";
+declare class BuildSyncRecordImpl implements Abstraction.Interface {
+    private readonly fieldIndexRegistry;
+    private readonly compressionHandler;
+    constructor(fieldIndexRegistry: CmsEntryOpenSearchFieldIndexRegistry.Interface, compressionHandler: CompressionHandler.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: Abstraction.Params<T>): Promise<{
+        id: string;
+        entryId: string;
+        index: string;
+        operation: OperationType;
+        data: string;
+        tenant: string;
+    }>;
+}
+export declare const BuildSyncRecord: typeof BuildSyncRecordImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/BuildSyncRecord.js").IBuildSyncRecord>;
+};
+export {};

package/features/SyncWriter/BuildSyncRecord.js

@@ -0,0 +1,56 @@
+import { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+import { CmsEntryOpenSearchFieldIndexRegistry } from "@webiny/api-headless-cms-utils-os/exports/api/cms/opensearch.js";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+import { transformEntryToIndex } from "@webiny/api-headless-cms-utils-os/operations/entry/transformations/transformEntryToIndex.js";
+import { createLatestRecordType, createPublishedRecordType } from "@webiny/api-headless-cms-utils-os/operations/entry/recordType.js";
+import { configurations } from "@webiny/api-headless-cms-utils-os/configurations.js";
+import { OperationType } from "@webiny/api-sync-to-opensearch/features/Operations/Operations.js";
+class BuildSyncRecordImpl {
+    constructor(fieldIndexRegistry, compressionHandler){
+        this.fieldIndexRegistry = fieldIndexRegistry;
+        this.compressionHandler = compressionHandler;
+    }
+    async execute(params) {
+        const { model, entry, storageEntry, kind } = params;
+        const indexEntry = transformEntryToIndex({
+            model,
+            entry,
+            storageEntry,
+            fieldIndexRegistry: this.fieldIndexRegistry
+        });
+        const isLatest = "latest" === kind;
+        const recordType = isLatest ? createLatestRecordType() : createPublishedRecordType();
+        const document = {
+            ...indexEntry,
+            ...isLatest ? {
+                latest: true
+            } : {
+                published: true
+            },
+            TYPE: recordType,
+            __type: recordType
+        };
+        const compressed = await this.compressionHandler.compress(document);
+        const { index } = configurations.es({
+            model
+        });
+        return {
+            id: `${entry.entryId}:${isLatest ? "L" : "P"}`,
+            entryId: entry.entryId,
+            index,
+            operation: OperationType.MODIFY,
+            data: JSON.stringify(compressed),
+            tenant: entry.tenant
+        };
+    }
+}
+const BuildSyncRecord_BuildSyncRecord = BuildSyncRecord.createImplementation({
+    implementation: BuildSyncRecordImpl,
+    dependencies: [
+        CmsEntryOpenSearchFieldIndexRegistry,
+        CompressionHandler
+    ]
+});
+export { BuildSyncRecord_BuildSyncRecord as BuildSyncRecord };
+
+//# sourceMappingURL=BuildSyncRecord.js.map

package/features/SyncWriter/BuildSyncRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/BuildSyncRecord.js","sources":["../../../src/features/SyncWriter/BuildSyncRecord.ts"],"sourcesContent":["import type { CmsEntryValues } from \"@webiny/api-headless-cms/types/index.js\";\nimport { BuildSyncRecord as Abstraction } from \"./abstractions/BuildSyncRecord.js\";\nimport { CmsEntryOpenSearchFieldIndexRegistry } from \"@webiny/api-headless-cms-utils-os/exports/api/cms/opensearch.js\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\nimport { transformEntryToIndex } from \"@webiny/api-headless-cms-utils-os/operations/entry/transformations/transformEntryToIndex.js\";\nimport {\n    createLatestRecordType,\n    createPublishedRecordType\n} from \"@webiny/api-headless-cms-utils-os/operations/entry/recordType.js\";\nimport { configurations } from \"@webiny/api-headless-cms-utils-os/configurations.js\";\nimport { OperationType } from \"@webiny/api-sync-to-opensearch/features/Operations/Operations.js\";\n\nclass BuildSyncRecordImpl implements Abstraction.Interface {\n    public constructor(\n        private readonly fieldIndexRegistry: CmsEntryOpenSearchFieldIndexRegistry.Interface,\n        private readonly compressionHandler: CompressionHandler.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = CmsEntryValues>(params: Abstraction.Params<T>) {\n        const { model, entry, storageEntry, kind } = params;\n\n        const indexEntry = transformEntryToIndex({\n            model,\n            entry,\n            storageEntry,\n            fieldIndexRegistry: this.fieldIndexRegistry\n        });\n\n        const isLatest = kind === \"latest\";\n        const recordType = isLatest ? createLatestRecordType() : createPublishedRecordType();\n\n        const document = {\n            ...indexEntry,\n            ...(isLatest ? { latest: true } : { published: true }),\n            TYPE: recordType,\n            __type: recordType\n        };\n\n        const compressed = await this.compressionHandler.compress(document);\n        const { index } = configurations.es({ model });\n\n        return {\n            id: `${entry.entryId}:${isLatest ? \"L\" : \"P\"}`,\n            entryId: entry.entryId,\n            index,\n            operation: OperationType.MODIFY,\n            data: JSON.stringify(compressed),\n            tenant: entry.tenant\n        };\n    }\n}\n\nexport const BuildSyncRecord = Abstraction.createImplementation({\n    implementation: BuildSyncRecordImpl,\n    dependencies: [CmsEntryOpenSearchFieldIndexRegistry, CompressionHandler]\n});\n"],"names":["BuildSyncRecordImpl","fieldIndexRegistry","compressionHandler","params","model","entry","storageEntry","kind","indexEntry","transformEntryToIndex","isLatest","recordType","createLatestRecordType","createPublishedRecordType","document","compressed","index","configurations","OperationType","JSON","BuildSyncRecord","Abstraction","CmsEntryOpenSearchFieldIndexRegistry","CompressionHandler"],"mappings":";;;;;;;AAYA,MAAMA;IACF,YACqBC,kBAAkE,EAClEC,kBAAgD,CACnE;aAFmBD,kBAAkB,GAAlBA;aACAC,kBAAkB,GAAlBA;IAClB;IAEH,MAAa,QAAmDC,MAA6B,EAAE;QAC3F,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,YAAY,EAAEC,IAAI,EAAE,GAAGJ;QAE7C,MAAMK,aAAaC,sBAAsB;YACrCL;YACAC;YACAC;YACA,oBAAoB,IAAI,CAAC,kBAAkB;QAC/C;QAEA,MAAMI,WAAWH,AAAS,aAATA;QACjB,MAAMI,aAAaD,WAAWE,2BAA2BC;QAEzD,MAAMC,WAAW;YACb,GAAGN,UAAU;YACb,GAAIE,WAAW;gBAAE,QAAQ;YAAK,IAAI;gBAAE,WAAW;YAAK,CAAC;YACrD,MAAMC;YACN,QAAQA;QACZ;QAEA,MAAMI,aAAa,MAAM,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAACD;QAC1D,MAAM,EAAEE,KAAK,EAAE,GAAGC,eAAe,EAAE,CAAC;YAAEb;QAAM;QAE5C,OAAO;YACH,IAAI,GAAGC,MAAM,OAAO,CAAC,CAAC,EAAEK,WAAW,MAAM,KAAK;YAC9C,SAASL,MAAM,OAAO;YACtBW;YACA,WAAWE,cAAc,MAAM;YAC/B,MAAMC,KAAK,SAAS,CAACJ;YACrB,QAAQV,MAAM,MAAM;QACxB;IACJ;AACJ;AAEO,MAAMe,kCAAkBC,gBAAAA,oBAAgC,CAAC;IAC5D,gBAAgBrB;IAChB,cAAc;QAACsB;QAAsCC;KAAmB;AAC5E"}

package/features/SyncWriter/RemoveEntry.d.ts

@@ -0,0 +1,11 @@
+import { RemoveEntry as Abstraction } from "./abstractions/RemoveEntry.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+declare class RemoveEntryImpl implements Abstraction.Interface {
+    private readonly syncRowQuery;
+    constructor(syncRowQuery: SyncRowQuery.Interface);
+    execute(params: Abstraction.Params): Promise<void>;
+}
+export declare const RemoveEntry: typeof RemoveEntryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/RemoveEntry.js").IRemoveEntry>;
+};
+export {};

package/features/SyncWriter/RemoveEntry.js

@@ -0,0 +1,23 @@
+import { RemoveEntry } from "./abstractions/RemoveEntry.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+class RemoveEntryImpl {
+    constructor(syncRowQuery){
+        this.syncRowQuery = syncRowQuery;
+    }
+    async execute(params) {
+        const { entryId } = params;
+        await this.syncRowQuery.create().whereIn("id", [
+            `${entryId}:L`,
+            `${entryId}:P`
+        ]).delete();
+    }
+}
+const RemoveEntry_RemoveEntry = RemoveEntry.createImplementation({
+    implementation: RemoveEntryImpl,
+    dependencies: [
+        SyncRowQuery
+    ]
+});
+export { RemoveEntry_RemoveEntry as RemoveEntry };
+
+//# sourceMappingURL=RemoveEntry.js.map

package/features/SyncWriter/RemoveEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/RemoveEntry.js","sources":["../../../src/features/SyncWriter/RemoveEntry.ts"],"sourcesContent":["import { RemoveEntry as Abstraction } from \"./abstractions/RemoveEntry.js\";\nimport { SyncRowQuery } from \"./abstractions/SyncRowQuery.js\";\n\nclass RemoveEntryImpl implements Abstraction.Interface {\n    public constructor(private readonly syncRowQuery: SyncRowQuery.Interface) {}\n\n    public async execute(params: Abstraction.Params) {\n        const { entryId } = params;\n        await this.syncRowQuery\n            .create()\n            .whereIn(\"id\", [`${entryId}:L`, `${entryId}:P`])\n            .delete();\n    }\n}\n\nexport const RemoveEntry = Abstraction.createImplementation({\n    implementation: RemoveEntryImpl,\n    dependencies: [SyncRowQuery]\n});\n"],"names":["RemoveEntryImpl","syncRowQuery","params","entryId","RemoveEntry","Abstraction","SyncRowQuery"],"mappings":";;AAGA,MAAMA;IACF,YAAoCC,YAAoC,CAAE;aAAtCA,YAAY,GAAZA;IAAuC;IAE3E,MAAa,QAAQC,MAA0B,EAAE;QAC7C,MAAM,EAAEC,OAAO,EAAE,GAAGD;QACpB,MAAM,IAAI,CAAC,YAAY,CAClB,MAAM,GACN,OAAO,CAAC,MAAM;YAAC,GAAGC,QAAQ,EAAE,CAAC;YAAE,GAAGA,QAAQ,EAAE,CAAC;SAAC,EAC9C,MAAM;IACf;AACJ;AAEO,MAAMC,0BAAcC,YAAAA,oBAAgC,CAAC;IACxD,gBAAgBL;IAChB,cAAc;QAACM;KAAa;AAChC"}

package/features/SyncWriter/RemoveLatest.d.ts

@@ -0,0 +1,11 @@
+import { RemoveLatest as Abstraction } from "./abstractions/RemoveLatest.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+declare class RemoveLatestImpl implements Abstraction.Interface {
+    private readonly syncRowQuery;
+    constructor(syncRowQuery: SyncRowQuery.Interface);
+    execute(params: Abstraction.Params): Promise<void>;
+}
+export declare const RemoveLatest: typeof RemoveLatestImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/RemoveLatest.js").IRemoveLatest>;
+};
+export {};

package/features/SyncWriter/RemoveLatest.js

@@ -0,0 +1,19 @@
+import { RemoveLatest } from "./abstractions/RemoveLatest.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+class RemoveLatestImpl {
+    constructor(syncRowQuery){
+        this.syncRowQuery = syncRowQuery;
+    }
+    async execute(params) {
+        await this.syncRowQuery.create().where("id", `${params.entryId}:L`).delete();
+    }
+}
+const RemoveLatest_RemoveLatest = RemoveLatest.createImplementation({
+    implementation: RemoveLatestImpl,
+    dependencies: [
+        SyncRowQuery
+    ]
+});
+export { RemoveLatest_RemoveLatest as RemoveLatest };
+
+//# sourceMappingURL=RemoveLatest.js.map

package/features/SyncWriter/RemoveLatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/RemoveLatest.js","sources":["../../../src/features/SyncWriter/RemoveLatest.ts"],"sourcesContent":["import { RemoveLatest as Abstraction } from \"./abstractions/RemoveLatest.js\";\nimport { SyncRowQuery } from \"./abstractions/SyncRowQuery.js\";\n\nclass RemoveLatestImpl implements Abstraction.Interface {\n    public constructor(private readonly syncRowQuery: SyncRowQuery.Interface) {}\n\n    public async execute(params: Abstraction.Params) {\n        await this.syncRowQuery.create().where(\"id\", `${params.entryId}:L`).delete();\n    }\n}\n\nexport const RemoveLatest = Abstraction.createImplementation({\n    implementation: RemoveLatestImpl,\n    dependencies: [SyncRowQuery]\n});\n"],"names":["RemoveLatestImpl","syncRowQuery","params","RemoveLatest","Abstraction","SyncRowQuery"],"mappings":";;AAGA,MAAMA;IACF,YAAoCC,YAAoC,CAAE;aAAtCA,YAAY,GAAZA;IAAuC;IAE3E,MAAa,QAAQC,MAA0B,EAAE;QAC7C,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,GAAGA,OAAO,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM;IAC9E;AACJ;AAEO,MAAMC,4BAAeC,aAAAA,oBAAgC,CAAC;IACzD,gBAAgBJ;IAChB,cAAc;QAACK;KAAa;AAChC"}

package/features/SyncWriter/RemovePublished.d.ts

@@ -0,0 +1,11 @@
+import { RemovePublished as Abstraction } from "./abstractions/RemovePublished.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+declare class RemovePublishedImpl implements Abstraction.Interface {
+    private readonly syncRowQuery;
+    constructor(syncRowQuery: SyncRowQuery.Interface);
+    execute(params: Abstraction.Params): Promise<void>;
+}
+export declare const RemovePublished: typeof RemovePublishedImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/RemovePublished.js").IRemovePublished>;
+};
+export {};

package/features/SyncWriter/RemovePublished.js

@@ -0,0 +1,19 @@
+import { RemovePublished } from "./abstractions/RemovePublished.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+class RemovePublishedImpl {
+    constructor(syncRowQuery){
+        this.syncRowQuery = syncRowQuery;
+    }
+    async execute(params) {
+        await this.syncRowQuery.create().where("id", `${params.entryId}:P`).delete();
+    }
+}
+const RemovePublished_RemovePublished = RemovePublished.createImplementation({
+    implementation: RemovePublishedImpl,
+    dependencies: [
+        SyncRowQuery
+    ]
+});
+export { RemovePublished_RemovePublished as RemovePublished };
+
+//# sourceMappingURL=RemovePublished.js.map

package/features/SyncWriter/RemovePublished.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/RemovePublished.js","sources":["../../../src/features/SyncWriter/RemovePublished.ts"],"sourcesContent":["import { RemovePublished as Abstraction } from \"./abstractions/RemovePublished.js\";\nimport { SyncRowQuery } from \"./abstractions/SyncRowQuery.js\";\n\nclass RemovePublishedImpl implements Abstraction.Interface {\n    public constructor(private readonly syncRowQuery: SyncRowQuery.Interface) {}\n\n    public async execute(params: Abstraction.Params) {\n        await this.syncRowQuery.create().where(\"id\", `${params.entryId}:P`).delete();\n    }\n}\n\nexport const RemovePublished = Abstraction.createImplementation({\n    implementation: RemovePublishedImpl,\n    dependencies: [SyncRowQuery]\n});\n"],"names":["RemovePublishedImpl","syncRowQuery","params","RemovePublished","Abstraction","SyncRowQuery"],"mappings":";;AAGA,MAAMA;IACF,YAAoCC,YAAoC,CAAE;aAAtCA,YAAY,GAAZA;IAAuC;IAE3E,MAAa,QAAQC,MAA0B,EAAE;QAC7C,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,GAAGA,OAAO,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM;IAC9E;AACJ;AAEO,MAAMC,kCAAkBC,gBAAAA,oBAAgC,CAAC;IAC5D,gBAAgBJ;IAChB,cAAc;QAACK;KAAa;AAChC"}

package/features/SyncWriter/SyncHelpers.d.ts

@@ -0,0 +1,26 @@
+import type { CmsEntry, CmsEntryValues, CmsModel, CmsStorageEntry, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { SyncHelpers as Abstraction } from "./abstractions/SyncHelpers.js";
+import { WriteEntry } from "./abstractions/WriteEntry.js";
+import { WriteLatest } from "./abstractions/WriteLatest.js";
+import { WritePublished } from "./abstractions/WritePublished.js";
+import { RemovePublished } from "./abstractions/RemovePublished.js";
+import { SyncTableManager } from "../../features/syncTableManager/abstractions.js";
+import { GetLatestRevisionByEntryIdStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/GetLatestRevisionByEntryIdStorageOperation.js";
+import { GetPublishedRevisionByEntryIdStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/GetPublishedRevisionByEntryIdStorageOperation.js";
+declare class SyncHelpersImpl implements Abstraction.Interface {
+    private readonly syncTableManager;
+    private readonly writeEntry;
+    private readonly writeLatest;
+    private readonly writePublished;
+    private readonly removePublished;
+    private readonly getLatestRevision;
+    private readonly getPublishedRevision;
+    constructor(syncTableManager: SyncTableManager.Interface, writeEntry: WriteEntry.Interface, writeLatest: WriteLatest.Interface, writePublished: WritePublished.Interface, removePublished: RemovePublished.Interface, getLatestRevision: GetLatestRevisionByEntryIdStorageOperation.Interface, getPublishedRevision: GetPublishedRevisionByEntryIdStorageOperation.Interface);
+    ensureSyncTable(): Promise<void>;
+    writeSyncForEntry<T extends CmsEntryValues>(model: StorageOperationsCmsModel<T>, entry: CmsEntry<T>, storageEntry: CmsStorageEntry<T>): Promise<void>;
+    resyncLatestAndPublishedFromPg<T extends CmsEntryValues = CmsEntryValues>(initialModel: CmsModel, model: StorageOperationsCmsModel<T>, id: string): Promise<void>;
+}
+export declare const SyncHelpers: typeof SyncHelpersImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/SyncHelpers.js").ISyncHelpers>;
+};
+export {};

package/features/SyncWriter/SyncHelpers.js

@@ -0,0 +1,70 @@
+import { parseIdentifier } from "@webiny/utils";
+import { SyncHelpers } from "./abstractions/SyncHelpers.js";
+import { WriteEntry } from "./abstractions/WriteEntry.js";
+import { WriteLatest } from "./abstractions/WriteLatest.js";
+import { WritePublished } from "./abstractions/WritePublished.js";
+import { RemovePublished } from "./abstractions/RemovePublished.js";
+import { SyncTableManager } from "../syncTableManager/abstractions.js";
+import { GetLatestRevisionByEntryIdStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/GetLatestRevisionByEntryIdStorageOperation.js";
+import { GetPublishedRevisionByEntryIdStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/GetPublishedRevisionByEntryIdStorageOperation.js";
+class SyncHelpersImpl {
+    constructor(syncTableManager, writeEntry, writeLatest, writePublished, removePublished, getLatestRevision, getPublishedRevision){
+        this.syncTableManager = syncTableManager;
+        this.writeEntry = writeEntry;
+        this.writeLatest = writeLatest;
+        this.writePublished = writePublished;
+        this.removePublished = removePublished;
+        this.getLatestRevision = getLatestRevision;
+        this.getPublishedRevision = getPublishedRevision;
+    }
+    async ensureSyncTable() {
+        await this.syncTableManager.ensureTable();
+    }
+    async writeSyncForEntry(model, entry, storageEntry) {
+        await this.writeEntry.execute({
+            model,
+            entry,
+            storageEntry
+        });
+    }
+    async resyncLatestAndPublishedFromPg(initialModel, model, id) {
+        const latest = await this.getLatestRevision.execute(initialModel, {
+            id
+        });
+        if (latest) await this.writeLatest.execute({
+            model,
+            entry: latest,
+            storageEntry: latest
+        });
+        const published = await this.getPublishedRevision.execute(initialModel, {
+            id
+        });
+        if (published) await this.writePublished.execute({
+            model,
+            entry: published,
+            storageEntry: published
+        });
+        else {
+            const { id: entryId } = parseIdentifier(id);
+            await this.removePublished.execute({
+                model,
+                entryId
+            });
+        }
+    }
+}
+const SyncHelpers_SyncHelpers = SyncHelpers.createImplementation({
+    implementation: SyncHelpersImpl,
+    dependencies: [
+        SyncTableManager,
+        WriteEntry,
+        WriteLatest,
+        WritePublished,
+        RemovePublished,
+        GetLatestRevisionByEntryIdStorageOperation,
+        GetPublishedRevisionByEntryIdStorageOperation
+    ]
+});
+export { SyncHelpers_SyncHelpers as SyncHelpers };
+
+//# sourceMappingURL=SyncHelpers.js.map

package/features/SyncWriter/SyncHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/SyncHelpers.js","sources":["../../../src/features/SyncWriter/SyncHelpers.ts"],"sourcesContent":["import type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    CmsStorageEntry,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport { SyncHelpers as Abstraction } from \"./abstractions/SyncHelpers.js\";\nimport { WriteEntry } from \"./abstractions/WriteEntry.js\";\nimport { WriteLatest } from \"./abstractions/WriteLatest.js\";\nimport { WritePublished } from \"./abstractions/WritePublished.js\";\nimport { RemovePublished } from \"./abstractions/RemovePublished.js\";\nimport { SyncTableManager } from \"~/features/syncTableManager/abstractions.js\";\nimport { GetLatestRevisionByEntryIdStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/GetLatestRevisionByEntryIdStorageOperation.js\";\nimport { GetPublishedRevisionByEntryIdStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/GetPublishedRevisionByEntryIdStorageOperation.js\";\n\nclass SyncHelpersImpl implements Abstraction.Interface {\n    public constructor(\n        private readonly syncTableManager: SyncTableManager.Interface,\n        private readonly writeEntry: WriteEntry.Interface,\n        private readonly writeLatest: WriteLatest.Interface,\n        private readonly writePublished: WritePublished.Interface,\n        private readonly removePublished: RemovePublished.Interface,\n        private readonly getLatestRevision: GetLatestRevisionByEntryIdStorageOperation.Interface,\n        private readonly getPublishedRevision: GetPublishedRevisionByEntryIdStorageOperation.Interface\n    ) {}\n\n    public async ensureSyncTable(): Promise<void> {\n        await this.syncTableManager.ensureTable();\n    }\n\n    public async writeSyncForEntry<T extends CmsEntryValues>(\n        model: StorageOperationsCmsModel<T>,\n        entry: CmsEntry<T>,\n        storageEntry: CmsStorageEntry<T>\n    ): Promise<void> {\n        await this.writeEntry.execute({ model, entry, storageEntry });\n    }\n\n    public async resyncLatestAndPublishedFromPg<T extends CmsEntryValues = CmsEntryValues>(\n        initialModel: CmsModel,\n        model: StorageOperationsCmsModel<T>,\n        id: string\n    ): Promise<void> {\n        const latest = await this.getLatestRevision.execute<T>(initialModel, { id });\n        if (latest) {\n            await this.writeLatest.execute({ model, entry: latest, storageEntry: latest });\n        }\n\n        const published = await this.getPublishedRevision.execute<T>(initialModel, { id });\n        if (published) {\n            await this.writePublished.execute({\n                model,\n                entry: published,\n                storageEntry: published\n            });\n        } else {\n            const { id: entryId } = parseIdentifier(id);\n            await this.removePublished.execute({ model, entryId });\n        }\n    }\n}\n\nexport const SyncHelpers = Abstraction.createImplementation({\n    implementation: SyncHelpersImpl,\n    dependencies: [\n        SyncTableManager,\n        WriteEntry,\n        WriteLatest,\n        WritePublished,\n        RemovePublished,\n        GetLatestRevisionByEntryIdStorageOperation,\n        GetPublishedRevisionByEntryIdStorageOperation\n    ]\n});\n"],"names":["SyncHelpersImpl","syncTableManager","writeEntry","writeLatest","writePublished","removePublished","getLatestRevision","getPublishedRevision","model","entry","storageEntry","initialModel","id","latest","published","entryId","parseIdentifier","SyncHelpers","Abstraction","SyncTableManager","WriteEntry","WriteLatest","WritePublished","RemovePublished","GetLatestRevisionByEntryIdStorageOperation","GetPublishedRevisionByEntryIdStorageOperation"],"mappings":";;;;;;;;;AAiBA,MAAMA;IACF,YACqBC,gBAA4C,EAC5CC,UAAgC,EAChCC,WAAkC,EAClCC,cAAwC,EACxCC,eAA0C,EAC1CC,iBAAuE,EACvEC,oBAA6E,CAChG;aAPmBN,gBAAgB,GAAhBA;aACAC,UAAU,GAAVA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;aACAC,eAAe,GAAfA;aACAC,iBAAiB,GAAjBA;aACAC,oBAAoB,GAApBA;IAClB;IAEH,MAAa,kBAAiC;QAC1C,MAAM,IAAI,CAAC,gBAAgB,CAAC,WAAW;IAC3C;IAEA,MAAa,kBACTC,KAAmC,EACnCC,KAAkB,EAClBC,YAAgC,EACnB;QACb,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YAAEF;YAAOC;YAAOC;QAAa;IAC/D;IAEA,MAAa,+BACTC,YAAsB,EACtBH,KAAmC,EACnCI,EAAU,EACG;QACb,MAAMC,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAIF,cAAc;YAAEC;QAAG;QAC1E,IAAIC,QACA,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YAAEL;YAAO,OAAOK;YAAQ,cAAcA;QAAO;QAGhF,MAAMC,YAAY,MAAM,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAIH,cAAc;YAAEC;QAAG;QAChF,IAAIE,WACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;YAC9BN;YACA,OAAOM;YACP,cAAcA;QAClB;aACG;YACH,MAAM,EAAE,IAAIC,OAAO,EAAE,GAAGC,gBAAgBJ;YACxC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;gBAAEJ;gBAAOO;YAAQ;QACxD;IACJ;AACJ;AAEO,MAAME,0BAAcC,YAAAA,oBAAgC,CAAC;IACxD,gBAAgBlB;IAChB,cAAc;QACVmB;QACAC;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/SyncWriter/SyncRowQuery.d.ts

@@ -0,0 +1,22 @@
+import { SyncRowQuery as Abstraction } from "./abstractions/SyncRowQuery.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { SyncTableManager } from "../../features/syncTableManager/abstractions.js";
+import type { ISyncRow } from "../../types.js";
+declare class SyncRowQueryImpl implements Abstraction.Interface {
+    private readonly knexClient;
+    private readonly syncTableManager;
+    constructor(knexClient: KnexClient.Interface, syncTableManager: SyncTableManager.Interface);
+    create(): import("knex").Knex.QueryBuilder<ISyncRow, {
+        _base: ISyncRow;
+        _hasSelection: false;
+        _keys: never;
+        _aliases: {};
+        _single: false;
+        _intersectProps: {};
+        _unionProps: never;
+    }[]>;
+}
+export declare const SyncRowQuery: typeof SyncRowQueryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/SyncRowQuery.js").ISyncRowQuery>;
+};
+export {};

package/features/SyncWriter/SyncRowQuery.js

@@ -0,0 +1,22 @@
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { SyncTableManager } from "../syncTableManager/abstractions.js";
+class SyncRowQueryImpl {
+    constructor(knexClient, syncTableManager){
+        this.knexClient = knexClient;
+        this.syncTableManager = syncTableManager;
+    }
+    create() {
+        return this.knexClient.client(this.syncTableManager.getTableName());
+    }
+}
+const SyncRowQuery_SyncRowQuery = SyncRowQuery.createImplementation({
+    implementation: SyncRowQueryImpl,
+    dependencies: [
+        KnexClient,
+        SyncTableManager
+    ]
+});
+export { SyncRowQuery_SyncRowQuery as SyncRowQuery };
+
+//# sourceMappingURL=SyncRowQuery.js.map

package/features/SyncWriter/SyncRowQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/SyncRowQuery.js","sources":["../../../src/features/SyncWriter/SyncRowQuery.ts"],"sourcesContent":["import { SyncRowQuery as Abstraction } from \"./abstractions/SyncRowQuery.js\";\nimport { KnexClient } from \"@webiny/api-core-sql\";\nimport { SyncTableManager } from \"~/features/syncTableManager/abstractions.js\";\nimport type { ISyncRow } from \"~/types.js\";\n\nclass SyncRowQueryImpl implements Abstraction.Interface {\n    public constructor(\n        private readonly knexClient: KnexClient.Interface,\n        private readonly syncTableManager: SyncTableManager.Interface\n    ) {}\n\n    public create() {\n        return this.knexClient.client<ISyncRow>(this.syncTableManager.getTableName());\n    }\n}\n\nexport const SyncRowQuery = Abstraction.createImplementation({\n    implementation: SyncRowQueryImpl,\n    dependencies: [KnexClient, SyncTableManager]\n});\n"],"names":["SyncRowQueryImpl","knexClient","syncTableManager","SyncRowQuery","Abstraction","KnexClient","SyncTableManager"],"mappings":";;;AAKA,MAAMA;IACF,YACqBC,UAAgC,EAChCC,gBAA4C,CAC/D;aAFmBD,UAAU,GAAVA;aACAC,gBAAgB,GAAhBA;IAClB;IAEI,SAAS;QACZ,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAW,IAAI,CAAC,gBAAgB,CAAC,YAAY;IAC9E;AACJ;AAEO,MAAMC,4BAAeC,aAAAA,oBAAgC,CAAC;IACzD,gBAAgBJ;IAChB,cAAc;QAACK;QAAYC;KAAiB;AAChD"}

package/features/SyncWriter/WriteEntry.d.ts

@@ -0,0 +1,14 @@
+import type { CmsEntryValues } from "@webiny/api-headless-cms/types/index.js";
+import { WriteEntry as Abstraction } from "./abstractions/WriteEntry.js";
+import { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+declare class WriteEntryImpl implements Abstraction.Interface {
+    private readonly buildSyncRecord;
+    private readonly syncRowQuery;
+    constructor(buildSyncRecord: BuildSyncRecord.Interface, syncRowQuery: SyncRowQuery.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: Abstraction.Params<T>): Promise<void>;
+}
+export declare const WriteEntry: typeof WriteEntryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/WriteEntry.js").IWriteEntry>;
+};
+export {};

package/features/SyncWriter/WriteEntry.js

@@ -0,0 +1,32 @@
+import { WriteEntry } from "./abstractions/WriteEntry.js";
+import { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+class WriteEntryImpl {
+    constructor(buildSyncRecord, syncRowQuery){
+        this.buildSyncRecord = buildSyncRecord;
+        this.syncRowQuery = syncRowQuery;
+    }
+    async execute(params) {
+        const rows = [
+            await this.buildSyncRecord.execute({
+                ...params,
+                kind: "latest"
+            })
+        ];
+        if ("published" === params.entry.status) rows.push(await this.buildSyncRecord.execute({
+            ...params,
+            kind: "published"
+        }));
+        await this.syncRowQuery.create().insert(rows).onConflict("id").merge();
+    }
+}
+const WriteEntry_WriteEntry = WriteEntry.createImplementation({
+    implementation: WriteEntryImpl,
+    dependencies: [
+        BuildSyncRecord,
+        SyncRowQuery
+    ]
+});
+export { WriteEntry_WriteEntry as WriteEntry };
+
+//# sourceMappingURL=WriteEntry.js.map

package/features/SyncWriter/WriteEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/WriteEntry.js","sources":["../../../src/features/SyncWriter/WriteEntry.ts"],"sourcesContent":["import type { CmsEntryValues } from \"@webiny/api-headless-cms/types/index.js\";\nimport { WriteEntry as Abstraction } from \"./abstractions/WriteEntry.js\";\nimport { BuildSyncRecord } from \"./abstractions/BuildSyncRecord.js\";\nimport { SyncRowQuery } from \"./abstractions/SyncRowQuery.js\";\nimport type { ISyncRow } from \"~/types.js\";\n\nclass WriteEntryImpl implements Abstraction.Interface {\n    public constructor(\n        private readonly buildSyncRecord: BuildSyncRecord.Interface,\n        private readonly syncRowQuery: SyncRowQuery.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = CmsEntryValues>(params: Abstraction.Params<T>) {\n        const rows: ISyncRow[] = [\n            await this.buildSyncRecord.execute({ ...params, kind: \"latest\" })\n        ];\n\n        if (params.entry.status === \"published\") {\n            rows.push(await this.buildSyncRecord.execute({ ...params, kind: \"published\" }));\n        }\n\n        await this.syncRowQuery.create().insert(rows).onConflict(\"id\").merge();\n    }\n}\n\nexport const WriteEntry = Abstraction.createImplementation({\n    implementation: WriteEntryImpl,\n    dependencies: [BuildSyncRecord, SyncRowQuery]\n});\n"],"names":["WriteEntryImpl","buildSyncRecord","syncRowQuery","params","rows","WriteEntry","Abstraction","BuildSyncRecord","SyncRowQuery"],"mappings":";;;AAMA,MAAMA;IACF,YACqBC,eAA0C,EAC1CC,YAAoC,CACvD;aAFmBD,eAAe,GAAfA;aACAC,YAAY,GAAZA;IAClB;IAEH,MAAa,QAAmDC,MAA6B,EAAE;QAC3F,MAAMC,OAAmB;YACrB,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;gBAAE,GAAGD,MAAM;gBAAE,MAAM;YAAS;SAClE;QAED,IAAIA,AAAwB,gBAAxBA,OAAO,KAAK,CAAC,MAAM,EACnBC,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;YAAE,GAAGD,MAAM;YAAE,MAAM;QAAY;QAGhF,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,MAAM,CAACC,MAAM,UAAU,CAAC,MAAM,KAAK;IACxE;AACJ;AAEO,MAAMC,wBAAaC,WAAAA,oBAAgC,CAAC;IACvD,gBAAgBN;IAChB,cAAc;QAACO;QAAiBC;KAAa;AACjD"}

package/features/SyncWriter/WriteLatest.d.ts

@@ -0,0 +1,14 @@
+import type { CmsEntryValues } from "@webiny/api-headless-cms/types/index.js";
+import { WriteLatest as Abstraction } from "./abstractions/WriteLatest.js";
+import { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+declare class WriteLatestImpl implements Abstraction.Interface {
+    private readonly buildSyncRecord;
+    private readonly syncRowQuery;
+    constructor(buildSyncRecord: BuildSyncRecord.Interface, syncRowQuery: SyncRowQuery.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: Abstraction.Params<T>): Promise<void>;
+}
+export declare const WriteLatest: typeof WriteLatestImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/WriteLatest.js").IWriteLatest>;
+};
+export {};

package/features/SyncWriter/WriteLatest.js

@@ -0,0 +1,26 @@
+import { WriteLatest } from "./abstractions/WriteLatest.js";
+import { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+class WriteLatestImpl {
+    constructor(buildSyncRecord, syncRowQuery){
+        this.buildSyncRecord = buildSyncRecord;
+        this.syncRowQuery = syncRowQuery;
+    }
+    async execute(params) {
+        const row = await this.buildSyncRecord.execute({
+            ...params,
+            kind: "latest"
+        });
+        await this.syncRowQuery.create().insert(row).onConflict("id").merge();
+    }
+}
+const WriteLatest_WriteLatest = WriteLatest.createImplementation({
+    implementation: WriteLatestImpl,
+    dependencies: [
+        BuildSyncRecord,
+        SyncRowQuery
+    ]
+});
+export { WriteLatest_WriteLatest as WriteLatest };
+
+//# sourceMappingURL=WriteLatest.js.map

package/features/SyncWriter/WriteLatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/WriteLatest.js","sources":["../../../src/features/SyncWriter/WriteLatest.ts"],"sourcesContent":["import type { CmsEntryValues } from \"@webiny/api-headless-cms/types/index.js\";\nimport { WriteLatest as Abstraction } from \"./abstractions/WriteLatest.js\";\nimport { BuildSyncRecord } from \"./abstractions/BuildSyncRecord.js\";\nimport { SyncRowQuery } from \"./abstractions/SyncRowQuery.js\";\n\nclass WriteLatestImpl implements Abstraction.Interface {\n    public constructor(\n        private readonly buildSyncRecord: BuildSyncRecord.Interface,\n        private readonly syncRowQuery: SyncRowQuery.Interface\n    ) {}\n\n    public async execute<T extends CmsEntryValues = CmsEntryValues>(params: Abstraction.Params<T>) {\n        const row = await this.buildSyncRecord.execute({ ...params, kind: \"latest\" });\n        await this.syncRowQuery.create().insert(row).onConflict(\"id\").merge();\n    }\n}\n\nexport const WriteLatest = Abstraction.createImplementation({\n    implementation: WriteLatestImpl,\n    dependencies: [BuildSyncRecord, SyncRowQuery]\n});\n"],"names":["WriteLatestImpl","buildSyncRecord","syncRowQuery","params","row","WriteLatest","Abstraction","BuildSyncRecord","SyncRowQuery"],"mappings":";;;AAKA,MAAMA;IACF,YACqBC,eAA0C,EAC1CC,YAAoC,CACvD;aAFmBD,eAAe,GAAfA;aACAC,YAAY,GAAZA;IAClB;IAEH,MAAa,QAAmDC,MAA6B,EAAE;QAC3F,MAAMC,MAAM,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC;YAAE,GAAGD,MAAM;YAAE,MAAM;QAAS;QAC3E,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,MAAM,CAACC,KAAK,UAAU,CAAC,MAAM,KAAK;IACvE;AACJ;AAEO,MAAMC,0BAAcC,YAAAA,oBAAgC,CAAC;IACxD,gBAAgBN;IAChB,cAAc;QAACO;QAAiBC;KAAa;AACjD"}

package/features/SyncWriter/WritePublished.d.ts

@@ -0,0 +1,14 @@
+import type { CmsEntryValues } from "@webiny/api-headless-cms/types/index.js";
+import { WritePublished as Abstraction } from "./abstractions/WritePublished.js";
+import { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+declare class WritePublishedImpl implements Abstraction.Interface {
+    private readonly buildSyncRecord;
+    private readonly syncRowQuery;
+    constructor(buildSyncRecord: BuildSyncRecord.Interface, syncRowQuery: SyncRowQuery.Interface);
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: Abstraction.Params<T>): Promise<void>;
+}
+export declare const WritePublished: typeof WritePublishedImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/WritePublished.js").IWritePublished>;
+};
+export {};

package/features/SyncWriter/WritePublished.js

@@ -0,0 +1,26 @@
+import { WritePublished } from "./abstractions/WritePublished.js";
+import { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+import { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+class WritePublishedImpl {
+    constructor(buildSyncRecord, syncRowQuery){
+        this.buildSyncRecord = buildSyncRecord;
+        this.syncRowQuery = syncRowQuery;
+    }
+    async execute(params) {
+        const row = await this.buildSyncRecord.execute({
+            ...params,
+            kind: "published"
+        });
+        await this.syncRowQuery.create().insert(row).onConflict("id").merge();
+    }
+}
+const WritePublished_WritePublished = WritePublished.createImplementation({
+    implementation: WritePublishedImpl,
+    dependencies: [
+        BuildSyncRecord,
+        SyncRowQuery
+    ]
+});
+export { WritePublished_WritePublished as WritePublished };
+
+//# sourceMappingURL=WritePublished.js.map