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

package/features/SyncWriter/WritePublished.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/WritePublished.js","sources":["../../../src/features/SyncWriter/WritePublished.ts"],"sourcesContent":["import type { CmsEntryValues } from \"@webiny/api-headless-cms/types/index.js\";\nimport { WritePublished as Abstraction } from \"./abstractions/WritePublished.js\";\nimport { BuildSyncRecord } from \"./abstractions/BuildSyncRecord.js\";\nimport { SyncRowQuery } from \"./abstractions/SyncRowQuery.js\";\n\nclass WritePublishedImpl 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: \"published\" });\n        await this.syncRowQuery.create().insert(row).onConflict(\"id\").merge();\n    }\n}\n\nexport const WritePublished = Abstraction.createImplementation({\n    implementation: WritePublishedImpl,\n    dependencies: [BuildSyncRecord, SyncRowQuery]\n});\n"],"names":["WritePublishedImpl","buildSyncRecord","syncRowQuery","params","row","WritePublished","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;QAAY;QAC9E,MAAM,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,MAAM,CAACC,KAAK,UAAU,CAAC,MAAM,KAAK;IACvE;AACJ;AAEO,MAAMC,gCAAiBC,eAAAA,oBAAgC,CAAC;IAC3D,gBAAgBN;IAChB,cAAc;QAACO;QAAiBC;KAAa;AACjD"}

package/features/SyncWriter/abstractions/BuildSyncRecord.d.ts

@@ -0,0 +1,18 @@
+import type { CmsEntry, CmsEntryValues, CmsStorageEntry, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+import type { ISyncRow } from "../../../types.js";
+export type RecordKind = "latest" | "published";
+export interface IBuildSyncRecordParams<T extends CmsEntryValues = CmsEntryValues> {
+    model: StorageOperationsCmsModel<T>;
+    entry: CmsEntry<T>;
+    storageEntry: CmsStorageEntry<T>;
+    kind: RecordKind;
+}
+export interface IBuildSyncRecord {
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: IBuildSyncRecordParams<T>): Promise<ISyncRow>;
+}
+export declare const BuildSyncRecord: import("@webiny/di").Abstraction<IBuildSyncRecord>;
+export declare namespace BuildSyncRecord {
+    type Interface = IBuildSyncRecord;
+    type Params<T extends CmsEntryValues = CmsEntryValues> = IBuildSyncRecordParams<T>;
+    type Kind = RecordKind;
+}

package/features/SyncWriter/abstractions/BuildSyncRecord.js

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

package/features/SyncWriter/abstractions/BuildSyncRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/BuildSyncRecord.js","sources":["../../../../src/features/SyncWriter/abstractions/BuildSyncRecord.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsStorageEntry,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport type { ISyncRow } from \"~/types.js\";\n\nexport type RecordKind = \"latest\" | \"published\";\n\nexport interface IBuildSyncRecordParams<T extends CmsEntryValues = CmsEntryValues> {\n    model: StorageOperationsCmsModel<T>;\n    entry: CmsEntry<T>;\n    storageEntry: CmsStorageEntry<T>;\n    kind: RecordKind;\n}\n\nexport interface IBuildSyncRecord {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        params: IBuildSyncRecordParams<T>\n    ): Promise<ISyncRow>;\n}\n\nexport const BuildSyncRecord = createAbstraction<IBuildSyncRecord>(\n    \"Cms/Pg/Os/SyncWriter/BuildSyncRecord\"\n);\n\nexport namespace BuildSyncRecord {\n    export type Interface = IBuildSyncRecord;\n    export type Params<T extends CmsEntryValues = CmsEntryValues> = IBuildSyncRecordParams<T>;\n    export type Kind = RecordKind;\n}\n"],"names":["BuildSyncRecord","createAbstraction"],"mappings":";AAwBO,MAAMA,kBAAkBC,kBAC3B"}

package/features/SyncWriter/abstractions/RemoveEntry.d.ts

@@ -0,0 +1,13 @@
+import type { StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IRemoveEntryParams {
+    model: Pick<StorageOperationsCmsModel, "tenant" | "modelId">;
+    entryId: string;
+}
+export interface IRemoveEntry {
+    execute(params: IRemoveEntryParams): Promise<void>;
+}
+export declare const RemoveEntry: import("@webiny/di").Abstraction<IRemoveEntry>;
+export declare namespace RemoveEntry {
+    type Interface = IRemoveEntry;
+    type Params = IRemoveEntryParams;
+}

package/features/SyncWriter/abstractions/RemoveEntry.js

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

package/features/SyncWriter/abstractions/RemoveEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/RemoveEntry.js","sources":["../../../../src/features/SyncWriter/abstractions/RemoveEntry.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { StorageOperationsCmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IRemoveEntryParams {\n    model: Pick<StorageOperationsCmsModel, \"tenant\" | \"modelId\">;\n    entryId: string;\n}\n\nexport interface IRemoveEntry {\n    execute(params: IRemoveEntryParams): Promise<void>;\n}\n\nexport const RemoveEntry = createAbstraction<IRemoveEntry>(\"Cms/Pg/Os/SyncWriter/RemoveEntry\");\n\nexport namespace RemoveEntry {\n    export type Interface = IRemoveEntry;\n    export type Params = IRemoveEntryParams;\n}\n"],"names":["RemoveEntry","createAbstraction"],"mappings":";AAYO,MAAMA,cAAcC,kBAAgC"}

package/features/SyncWriter/abstractions/RemoveLatest.d.ts

@@ -0,0 +1,13 @@
+import type { StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IRemoveLatestParams {
+    model: Pick<StorageOperationsCmsModel, "tenant" | "modelId">;
+    entryId: string;
+}
+export interface IRemoveLatest {
+    execute(params: IRemoveLatestParams): Promise<void>;
+}
+export declare const RemoveLatest: import("@webiny/di").Abstraction<IRemoveLatest>;
+export declare namespace RemoveLatest {
+    type Interface = IRemoveLatest;
+    type Params = IRemoveLatestParams;
+}

package/features/SyncWriter/abstractions/RemoveLatest.js

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

package/features/SyncWriter/abstractions/RemoveLatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/RemoveLatest.js","sources":["../../../../src/features/SyncWriter/abstractions/RemoveLatest.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { StorageOperationsCmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IRemoveLatestParams {\n    model: Pick<StorageOperationsCmsModel, \"tenant\" | \"modelId\">;\n    entryId: string;\n}\n\nexport interface IRemoveLatest {\n    execute(params: IRemoveLatestParams): Promise<void>;\n}\n\nexport const RemoveLatest = createAbstraction<IRemoveLatest>(\"Cms/Pg/Os/SyncWriter/RemoveLatest\");\n\nexport namespace RemoveLatest {\n    export type Interface = IRemoveLatest;\n    export type Params = IRemoveLatestParams;\n}\n"],"names":["RemoveLatest","createAbstraction"],"mappings":";AAYO,MAAMA,eAAeC,kBAAiC"}

package/features/SyncWriter/abstractions/RemovePublished.d.ts

@@ -0,0 +1,13 @@
+import type { StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IRemovePublishedParams {
+    model: Pick<StorageOperationsCmsModel, "tenant" | "modelId">;
+    entryId: string;
+}
+export interface IRemovePublished {
+    execute(params: IRemovePublishedParams): Promise<void>;
+}
+export declare const RemovePublished: import("@webiny/di").Abstraction<IRemovePublished>;
+export declare namespace RemovePublished {
+    type Interface = IRemovePublished;
+    type Params = IRemovePublishedParams;
+}

package/features/SyncWriter/abstractions/RemovePublished.js

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

package/features/SyncWriter/abstractions/RemovePublished.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/RemovePublished.js","sources":["../../../../src/features/SyncWriter/abstractions/RemovePublished.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { StorageOperationsCmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IRemovePublishedParams {\n    model: Pick<StorageOperationsCmsModel, \"tenant\" | \"modelId\">;\n    entryId: string;\n}\n\nexport interface IRemovePublished {\n    execute(params: IRemovePublishedParams): Promise<void>;\n}\n\nexport const RemovePublished = createAbstraction<IRemovePublished>(\n    \"Cms/Pg/Os/SyncWriter/RemovePublished\"\n);\n\nexport namespace RemovePublished {\n    export type Interface = IRemovePublished;\n    export type Params = IRemovePublishedParams;\n}\n"],"names":["RemovePublished","createAbstraction"],"mappings":";AAYO,MAAMA,kBAAkBC,kBAC3B"}

package/features/SyncWriter/abstractions/SyncHelpers.d.ts

@@ -0,0 +1,10 @@
+import type { CmsEntry, CmsEntryValues, CmsModel, CmsStorageEntry, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface ISyncHelpers {
+    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: import("@webiny/di").Abstraction<ISyncHelpers>;
+export declare namespace SyncHelpers {
+    type Interface = ISyncHelpers;
+}

package/features/SyncWriter/abstractions/SyncHelpers.js

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

package/features/SyncWriter/abstractions/SyncHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/SyncHelpers.js","sources":["../../../../src/features/SyncWriter/abstractions/SyncHelpers.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsModel,\n    CmsStorageEntry,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface ISyncHelpers {\n    ensureSyncTable(): Promise<void>;\n    writeSyncForEntry<T extends CmsEntryValues>(\n        model: StorageOperationsCmsModel<T>,\n        entry: CmsEntry<T>,\n        storageEntry: CmsStorageEntry<T>\n    ): Promise<void>;\n    resyncLatestAndPublishedFromPg<T extends CmsEntryValues = CmsEntryValues>(\n        initialModel: CmsModel,\n        model: StorageOperationsCmsModel<T>,\n        id: string\n    ): Promise<void>;\n}\n\nexport const SyncHelpers = createAbstraction<ISyncHelpers>(\"Cms/Pg/Os/SyncWriter/SyncHelpers\");\n\nexport namespace SyncHelpers {\n    export type Interface = ISyncHelpers;\n}\n"],"names":["SyncHelpers","createAbstraction"],"mappings":";AAuBO,MAAMA,cAAcC,kBAAgC"}

package/features/SyncWriter/abstractions/SyncRowQuery.d.ts

@@ -0,0 +1,9 @@
+import type { Knex } from "knex";
+import type { ISyncRow } from "../../../types.js";
+export interface ISyncRowQuery {
+    create(): Knex.QueryBuilder<ISyncRow>;
+}
+export declare const SyncRowQuery: import("@webiny/di").Abstraction<ISyncRowQuery>;
+export declare namespace SyncRowQuery {
+    type Interface = ISyncRowQuery;
+}

package/features/SyncWriter/abstractions/SyncRowQuery.js

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

package/features/SyncWriter/abstractions/SyncRowQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/SyncRowQuery.js","sources":["../../../../src/features/SyncWriter/abstractions/SyncRowQuery.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Knex } from \"knex\";\nimport type { ISyncRow } from \"~/types.js\";\n\nexport interface ISyncRowQuery {\n    create(): Knex.QueryBuilder<ISyncRow>;\n}\n\nexport const SyncRowQuery = createAbstraction<ISyncRowQuery>(\"Cms/Pg/Os/SyncWriter/SyncRowQuery\");\n\nexport namespace SyncRowQuery {\n    export type Interface = ISyncRowQuery;\n}\n"],"names":["SyncRowQuery","createAbstraction"],"mappings":";AAQO,MAAMA,eAAeC,kBAAiC"}

package/features/SyncWriter/abstractions/WriteEntry.d.ts

@@ -0,0 +1,14 @@
+import type { CmsEntry, CmsEntryValues, CmsStorageEntry, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IWriteEntryParams<T extends CmsEntryValues = CmsEntryValues> {
+    model: StorageOperationsCmsModel<T>;
+    entry: CmsEntry<T>;
+    storageEntry: CmsStorageEntry<T>;
+}
+export interface IWriteEntry {
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: IWriteEntryParams<T>): Promise<void>;
+}
+export declare const WriteEntry: import("@webiny/di").Abstraction<IWriteEntry>;
+export declare namespace WriteEntry {
+    type Interface = IWriteEntry;
+    type Params<T extends CmsEntryValues = CmsEntryValues> = IWriteEntryParams<T>;
+}

package/features/SyncWriter/abstractions/WriteEntry.js

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

package/features/SyncWriter/abstractions/WriteEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/WriteEntry.js","sources":["../../../../src/features/SyncWriter/abstractions/WriteEntry.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsStorageEntry,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IWriteEntryParams<T extends CmsEntryValues = CmsEntryValues> {\n    model: StorageOperationsCmsModel<T>;\n    entry: CmsEntry<T>;\n    storageEntry: CmsStorageEntry<T>;\n}\n\nexport interface IWriteEntry {\n    execute<T extends CmsEntryValues = CmsEntryValues>(params: IWriteEntryParams<T>): Promise<void>;\n}\n\nexport const WriteEntry = createAbstraction<IWriteEntry>(\"Cms/Pg/Os/SyncWriter/WriteEntry\");\n\nexport namespace WriteEntry {\n    export type Interface = IWriteEntry;\n    export type Params<T extends CmsEntryValues = CmsEntryValues> = IWriteEntryParams<T>;\n}\n"],"names":["WriteEntry","createAbstraction"],"mappings":";AAkBO,MAAMA,aAAaC,kBAA+B"}

package/features/SyncWriter/abstractions/WriteLatest.d.ts

@@ -0,0 +1,14 @@
+import type { CmsEntry, CmsEntryValues, CmsStorageEntry, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IWriteLatestParams<T extends CmsEntryValues = CmsEntryValues> {
+    model: StorageOperationsCmsModel<T>;
+    entry: CmsEntry<T>;
+    storageEntry: CmsStorageEntry<T>;
+}
+export interface IWriteLatest {
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: IWriteLatestParams<T>): Promise<void>;
+}
+export declare const WriteLatest: import("@webiny/di").Abstraction<IWriteLatest>;
+export declare namespace WriteLatest {
+    type Interface = IWriteLatest;
+    type Params<T extends CmsEntryValues = CmsEntryValues> = IWriteLatestParams<T>;
+}

package/features/SyncWriter/abstractions/WriteLatest.js

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

package/features/SyncWriter/abstractions/WriteLatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/WriteLatest.js","sources":["../../../../src/features/SyncWriter/abstractions/WriteLatest.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsStorageEntry,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IWriteLatestParams<T extends CmsEntryValues = CmsEntryValues> {\n    model: StorageOperationsCmsModel<T>;\n    entry: CmsEntry<T>;\n    storageEntry: CmsStorageEntry<T>;\n}\n\nexport interface IWriteLatest {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        params: IWriteLatestParams<T>\n    ): Promise<void>;\n}\n\nexport const WriteLatest = createAbstraction<IWriteLatest>(\"Cms/Pg/Os/SyncWriter/WriteLatest\");\n\nexport namespace WriteLatest {\n    export type Interface = IWriteLatest;\n    export type Params<T extends CmsEntryValues = CmsEntryValues> = IWriteLatestParams<T>;\n}\n"],"names":["WriteLatest","createAbstraction"],"mappings":";AAoBO,MAAMA,cAAcC,kBAAgC"}

package/features/SyncWriter/abstractions/WritePublished.d.ts

@@ -0,0 +1,14 @@
+import type { CmsEntry, CmsEntryValues, CmsStorageEntry, StorageOperationsCmsModel } from "@webiny/api-headless-cms/types/index.js";
+export interface IWritePublishedParams<T extends CmsEntryValues = CmsEntryValues> {
+    model: StorageOperationsCmsModel<T>;
+    entry: CmsEntry<T>;
+    storageEntry: CmsStorageEntry<T>;
+}
+export interface IWritePublished {
+    execute<T extends CmsEntryValues = CmsEntryValues>(params: IWritePublishedParams<T>): Promise<void>;
+}
+export declare const WritePublished: import("@webiny/di").Abstraction<IWritePublished>;
+export declare namespace WritePublished {
+    type Interface = IWritePublished;
+    type Params<T extends CmsEntryValues = CmsEntryValues> = IWritePublishedParams<T>;
+}

package/features/SyncWriter/abstractions/WritePublished.js

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

package/features/SyncWriter/abstractions/WritePublished.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/abstractions/WritePublished.js","sources":["../../../../src/features/SyncWriter/abstractions/WritePublished.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type {\n    CmsEntry,\n    CmsEntryValues,\n    CmsStorageEntry,\n    StorageOperationsCmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\n\nexport interface IWritePublishedParams<T extends CmsEntryValues = CmsEntryValues> {\n    model: StorageOperationsCmsModel<T>;\n    entry: CmsEntry<T>;\n    storageEntry: CmsStorageEntry<T>;\n}\n\nexport interface IWritePublished {\n    execute<T extends CmsEntryValues = CmsEntryValues>(\n        params: IWritePublishedParams<T>\n    ): Promise<void>;\n}\n\nexport const WritePublished = createAbstraction<IWritePublished>(\n    \"Cms/Pg/Os/SyncWriter/WritePublished\"\n);\n\nexport namespace WritePublished {\n    export type Interface = IWritePublished;\n    export type Params<T extends CmsEntryValues = CmsEntryValues> = IWritePublishedParams<T>;\n}\n"],"names":["WritePublished","createAbstraction"],"mappings":";AAoBO,MAAMA,iBAAiBC,kBAC1B"}

package/features/SyncWriter/feature.d.ts

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

package/features/SyncWriter/feature.js

@@ -0,0 +1,27 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { BuildSyncRecord } from "./BuildSyncRecord.js";
+import { WriteEntry } from "./WriteEntry.js";
+import { WriteLatest } from "./WriteLatest.js";
+import { WritePublished } from "./WritePublished.js";
+import { RemoveEntry } from "./RemoveEntry.js";
+import { RemoveLatest } from "./RemoveLatest.js";
+import { RemovePublished } from "./RemovePublished.js";
+import { SyncRowQuery } from "./SyncRowQuery.js";
+import { SyncHelpers } from "./SyncHelpers.js";
+const SyncWriterFeature = createFeature({
+    name: "Cms/Pg/Os/SyncWriter",
+    register (container) {
+        container.register(SyncRowQuery);
+        container.register(BuildSyncRecord);
+        container.register(WriteEntry);
+        container.register(WriteLatest);
+        container.register(WritePublished);
+        container.register(RemoveEntry);
+        container.register(RemoveLatest);
+        container.register(RemovePublished);
+        container.register(SyncHelpers);
+    }
+});
+export { SyncWriterFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/SyncWriter/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/SyncWriter/feature.js","sources":["../../../src/features/SyncWriter/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { BuildSyncRecord } from \"./BuildSyncRecord.js\";\nimport { WriteEntry } from \"./WriteEntry.js\";\nimport { WriteLatest } from \"./WriteLatest.js\";\nimport { WritePublished } from \"./WritePublished.js\";\nimport { RemoveEntry } from \"./RemoveEntry.js\";\nimport { RemoveLatest } from \"./RemoveLatest.js\";\nimport { RemovePublished } from \"./RemovePublished.js\";\nimport { SyncRowQuery } from \"./SyncRowQuery.js\";\nimport { SyncHelpers } from \"./SyncHelpers.js\";\n\nexport const SyncWriterFeature = createFeature({\n    name: \"Cms/Pg/Os/SyncWriter\",\n    register(container) {\n        container.register(SyncRowQuery);\n        container.register(BuildSyncRecord);\n        container.register(WriteEntry);\n        container.register(WriteLatest);\n        container.register(WritePublished);\n        container.register(RemoveEntry);\n        container.register(RemoveLatest);\n        container.register(RemovePublished);\n        container.register(SyncHelpers);\n    }\n});\n"],"names":["SyncWriterFeature","createFeature","container","SyncRowQuery","BuildSyncRecord","WriteEntry","WriteLatest","WritePublished","RemoveEntry","RemoveLatest","RemovePublished","SyncHelpers"],"mappings":";;;;;;;;;;AAWO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,QAAQ,CAACS;IACvB;AACJ"}

package/features/SyncWriter/index.d.ts

@@ -0,0 +1,9 @@
+export { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+export { WriteEntry } from "./abstractions/WriteEntry.js";
+export { WriteLatest } from "./abstractions/WriteLatest.js";
+export { WritePublished } from "./abstractions/WritePublished.js";
+export { RemoveEntry } from "./abstractions/RemoveEntry.js";
+export { RemoveLatest } from "./abstractions/RemoveLatest.js";
+export { RemovePublished } from "./abstractions/RemovePublished.js";
+export { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+export { SyncHelpers } from "./abstractions/SyncHelpers.js";

package/features/SyncWriter/index.js

@@ -0,0 +1,9 @@
+export { BuildSyncRecord } from "./abstractions/BuildSyncRecord.js";
+export { WriteEntry } from "./abstractions/WriteEntry.js";
+export { WriteLatest } from "./abstractions/WriteLatest.js";
+export { WritePublished } from "./abstractions/WritePublished.js";
+export { RemoveEntry } from "./abstractions/RemoveEntry.js";
+export { RemoveLatest } from "./abstractions/RemoveLatest.js";
+export { RemovePublished } from "./abstractions/RemovePublished.js";
+export { SyncRowQuery } from "./abstractions/SyncRowQuery.js";
+export { SyncHelpers } from "./abstractions/SyncHelpers.js";

package/features/syncEventHandler/SyncEventHandler.d.ts

@@ -0,0 +1,15 @@
+import { SyncEventHandler as SyncEventHandlerAbstraction } from "./abstractions.js";
+import { SynchronizationBuilder } from "@webiny/api-sync-to-opensearch";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+import type { SyncEvent } from "../../types.js";
+declare class SyncEventHandlerImpl implements SyncEventHandlerAbstraction.Interface {
+    private readonly synchronizationBuilder;
+    private readonly compressionHandler;
+    constructor(synchronizationBuilder: SynchronizationBuilder.Interface, compressionHandler: CompressionHandler.Interface);
+    process(events: SyncEvent[], options?: SyncEventHandlerAbstraction.ProcessOptions): Promise<void>;
+    private processBatch;
+}
+export declare const SyncEventHandler: typeof SyncEventHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ISyncEventHandler>;
+};
+export {};

package/features/syncEventHandler/SyncEventHandler.js

@@ -0,0 +1,49 @@
+import { SyncEventHandler } from "./abstractions.js";
+import { SynchronizationBuilder } from "@webiny/api-sync-to-opensearch";
+import { CompressionHandler } from "@webiny/utils/exports/api.js";
+const DEFAULT_BATCH_SIZE = 50;
+class SyncEventHandlerImpl {
+    constructor(synchronizationBuilder, compressionHandler){
+        this.synchronizationBuilder = synchronizationBuilder;
+        this.compressionHandler = compressionHandler;
+    }
+    async process(events, options) {
+        if (0 === events.length) return;
+        const batchSize = options?.batchSize ?? DEFAULT_BATCH_SIZE;
+        for(let i = 0; i < events.length; i += batchSize){
+            const batch = events.slice(i, i + batchSize);
+            await this.processBatch(batch);
+        }
+    }
+    async processBatch(events) {
+        for (const event of events){
+            if ("REMOVE" === event.type) {
+                this.synchronizationBuilder.delete({
+                    id: event.id,
+                    index: event.index
+                });
+                continue;
+            }
+            if (!event.data) continue;
+            const parsed = JSON.parse(event.data);
+            const decompressed = await this.compressionHandler.decompress(parsed);
+            this.synchronizationBuilder.insert({
+                id: event.id,
+                index: event.index,
+                data: decompressed
+            });
+        }
+        const flush = this.synchronizationBuilder.build();
+        await flush();
+    }
+}
+const SyncEventHandler_SyncEventHandler = SyncEventHandler.createImplementation({
+    implementation: SyncEventHandlerImpl,
+    dependencies: [
+        SynchronizationBuilder,
+        CompressionHandler
+    ]
+});
+export { SyncEventHandler_SyncEventHandler as SyncEventHandler };
+
+//# sourceMappingURL=SyncEventHandler.js.map

package/features/syncEventHandler/SyncEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/syncEventHandler/SyncEventHandler.js","sources":["../../../src/features/syncEventHandler/SyncEventHandler.ts"],"sourcesContent":["import { SyncEventHandler as SyncEventHandlerAbstraction } from \"./abstractions.js\";\nimport { SynchronizationBuilder } from \"@webiny/api-sync-to-opensearch\";\nimport { CompressionHandler } from \"@webiny/utils/exports/api.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { SyncEvent } from \"~/types.js\";\n\nconst DEFAULT_BATCH_SIZE = 50;\n\nclass SyncEventHandlerImpl implements SyncEventHandlerAbstraction.Interface {\n    public constructor(\n        private readonly synchronizationBuilder: SynchronizationBuilder.Interface,\n        private readonly compressionHandler: CompressionHandler.Interface\n    ) {}\n\n    public async process(\n        events: SyncEvent[],\n        options?: SyncEventHandlerAbstraction.ProcessOptions\n    ): Promise<void> {\n        if (events.length === 0) {\n            return;\n        }\n\n        const batchSize = options?.batchSize ?? DEFAULT_BATCH_SIZE;\n\n        for (let i = 0; i < events.length; i += batchSize) {\n            const batch = events.slice(i, i + batchSize);\n            await this.processBatch(batch);\n        }\n    }\n\n    private async processBatch(events: SyncEvent[]): Promise<void> {\n        for (const event of events) {\n            if (event.type === \"REMOVE\") {\n                this.synchronizationBuilder.delete({\n                    id: event.id,\n                    index: event.index\n                });\n                continue;\n            }\n\n            if (!event.data) {\n                continue;\n            }\n\n            const parsed = JSON.parse(event.data);\n            const decompressed = await this.compressionHandler.decompress<GenericRecord>(parsed);\n\n            this.synchronizationBuilder.insert({\n                id: event.id,\n                index: event.index,\n                data: decompressed\n            });\n        }\n\n        const flush = this.synchronizationBuilder.build();\n        await flush();\n    }\n}\n\nexport const SyncEventHandler = SyncEventHandlerAbstraction.createImplementation({\n    implementation: SyncEventHandlerImpl,\n    dependencies: [SynchronizationBuilder, CompressionHandler]\n});\n"],"names":["DEFAULT_BATCH_SIZE","SyncEventHandlerImpl","synchronizationBuilder","compressionHandler","events","options","batchSize","i","batch","event","parsed","JSON","decompressed","flush","SyncEventHandler","SyncEventHandlerAbstraction","SynchronizationBuilder","CompressionHandler"],"mappings":";;;AAMA,MAAMA,qBAAqB;AAE3B,MAAMC;IACF,YACqBC,sBAAwD,EACxDC,kBAAgD,CACnE;aAFmBD,sBAAsB,GAAtBA;aACAC,kBAAkB,GAAlBA;IAClB;IAEH,MAAa,QACTC,MAAmB,EACnBC,OAAoD,EACvC;QACb,IAAID,AAAkB,MAAlBA,OAAO,MAAM,EACb;QAGJ,MAAME,YAAYD,SAAS,aAAaL;QAExC,IAAK,IAAIO,IAAI,GAAGA,IAAIH,OAAO,MAAM,EAAEG,KAAKD,UAAW;YAC/C,MAAME,QAAQJ,OAAO,KAAK,CAACG,GAAGA,IAAID;YAClC,MAAM,IAAI,CAAC,YAAY,CAACE;QAC5B;IACJ;IAEA,MAAc,aAAaJ,MAAmB,EAAiB;QAC3D,KAAK,MAAMK,SAASL,OAAQ;YACxB,IAAIK,AAAe,aAAfA,MAAM,IAAI,EAAe;gBACzB,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC;oBAC/B,IAAIA,MAAM,EAAE;oBACZ,OAAOA,MAAM,KAAK;gBACtB;gBACA;YACJ;YAEA,IAAI,CAACA,MAAM,IAAI,EACX;YAGJ,MAAMC,SAASC,KAAK,KAAK,CAACF,MAAM,IAAI;YACpC,MAAMG,eAAe,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAgBF;YAE7E,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC;gBAC/B,IAAID,MAAM,EAAE;gBACZ,OAAOA,MAAM,KAAK;gBAClB,MAAMG;YACV;QACJ;QAEA,MAAMC,QAAQ,IAAI,CAAC,sBAAsB,CAAC,KAAK;QAC/C,MAAMA;IACV;AACJ;AAEO,MAAMC,oCAAmBC,iBAAAA,oBAAgD,CAAC;IAC7E,gBAAgBd;IAChB,cAAc;QAACe;QAAwBC;KAAmB;AAC9D"}

package/features/syncEventHandler/abstractions.d.ts

@@ -0,0 +1,12 @@
+import type { SyncEvent } from "../../types.js";
+export interface ISyncEventHandlerProcessOptions {
+    batchSize?: number;
+}
+export interface ISyncEventHandler {
+    process(events: SyncEvent[], options?: ISyncEventHandlerProcessOptions): Promise<void>;
+}
+export declare const SyncEventHandler: import("@webiny/di").Abstraction<ISyncEventHandler>;
+export declare namespace SyncEventHandler {
+    type Interface = ISyncEventHandler;
+    type ProcessOptions = ISyncEventHandlerProcessOptions;
+}

package/features/syncEventHandler/abstractions.js

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

package/features/syncEventHandler/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/syncEventHandler/abstractions.js","sources":["../../../src/features/syncEventHandler/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api/index.js\";\nimport type { SyncEvent } from \"~/types.js\";\n\nexport interface ISyncEventHandlerProcessOptions {\n    batchSize?: number;\n}\n\nexport interface ISyncEventHandler {\n    process(events: SyncEvent[], options?: ISyncEventHandlerProcessOptions): Promise<void>;\n}\n\nexport const SyncEventHandler = createAbstraction<ISyncEventHandler>(\"Cms/PgOs/SyncEventHandler\");\n\nexport namespace SyncEventHandler {\n    export type Interface = ISyncEventHandler;\n    export type ProcessOptions = ISyncEventHandlerProcessOptions;\n}\n"],"names":["SyncEventHandler","createAbstraction"],"mappings":";AAWO,MAAMA,mBAAmBC,kBAAqC"}

package/features/syncEventHandler/feature.d.ts

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

package/features/syncEventHandler/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { SyncEventHandler } from "./SyncEventHandler.js";
+const SyncEventHandlerFeature = createFeature({
+    name: "cms.pgOs.syncEventHandler",
+    register: (container)=>{
+        container.register(SyncEventHandler);
+    }
+});
+export { SyncEventHandlerFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/syncEventHandler/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/syncEventHandler/feature.js","sources":["../../../src/features/syncEventHandler/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { SyncEventHandler } from \"./SyncEventHandler.js\";\n\nexport const SyncEventHandlerFeature = createFeature({\n    name: \"cms.pgOs.syncEventHandler\",\n    register: container => {\n        container.register(SyncEventHandler);\n    }\n});\n"],"names":["SyncEventHandlerFeature","createFeature","container","SyncEventHandler"],"mappings":";;AAGO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/syncTableManager/SyncTableManager.d.ts

@@ -0,0 +1,19 @@
+import { KnexClient } from "@webiny/api-core-sql";
+import { SyncTableManager as SyncTableManagerAbstraction } from "./abstractions.js";
+import { TableNameResolver } from "@webiny/api-headless-cms-sql/features/tableNameResolver/abstractions.js";
+declare class SyncTableManagerImpl implements SyncTableManagerAbstraction.Interface {
+    private readonly knex;
+    private readonly tableName;
+    private initialized;
+    private initPromise?;
+    constructor(knex: KnexClient.Interface, tableNameResolver: TableNameResolver.Interface);
+    reset(): void;
+    ensureTable(): Promise<void>;
+    getTableName(): string;
+    private doEnsureTable;
+    private createTable;
+}
+export declare const SyncTableManager: typeof SyncTableManagerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ISyncTableManager>;
+};
+export {};

package/features/syncTableManager/SyncTableManager.js

@@ -0,0 +1,61 @@
+import { KnexClient } from "@webiny/api-core-sql";
+import { SyncTableManager } from "./abstractions.js";
+import { TableNameResolver } from "@webiny/api-headless-cms-sql/features/tableNameResolver/abstractions.js";
+class SyncTableManagerImpl {
+    constructor(knex, tableNameResolver){
+        this.initialized = false;
+        this.knex = knex;
+        this.tableName = tableNameResolver.resolve("os_sync");
+        const g = globalThis;
+        const managers = g.__sqlTableManagers ??= [];
+        managers.push(this);
+    }
+    reset() {
+        this.initialized = false;
+        this.initPromise = void 0;
+    }
+    async ensureTable() {
+        if (this.initialized) return;
+        if (!this.initPromise) this.initPromise = this.doEnsureTable().catch((err)=>{
+            this.initPromise = void 0;
+            throw err;
+        });
+        return this.initPromise;
+    }
+    getTableName() {
+        return this.tableName;
+    }
+    async doEnsureTable() {
+        const exists = await this.knex.client.schema.hasTable(this.tableName);
+        if (!exists) await this.createTable();
+        this.initialized = true;
+    }
+    async createTable() {
+        try {
+            await this.knex.client.schema.createTable(this.tableName, (table)=>{
+                table.text("id").primary();
+                table.text("entryId").notNullable();
+                table.text("index").notNullable();
+                table.text("operation").notNullable();
+                table.text("data").notNullable();
+                table.text("tenant").notNullable();
+                table.index([
+                    "tenant"
+                ]);
+            });
+        } catch (err) {
+            if (await this.knex.client.schema.hasTable(this.tableName)) return;
+            throw err;
+        }
+    }
+}
+const SyncTableManager_SyncTableManager = SyncTableManager.createImplementation({
+    implementation: SyncTableManagerImpl,
+    dependencies: [
+        KnexClient,
+        TableNameResolver
+    ]
+});
+export { SyncTableManager_SyncTableManager as SyncTableManager };
+
+//# sourceMappingURL=SyncTableManager.js.map

package/features/syncTableManager/SyncTableManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/syncTableManager/SyncTableManager.js","sources":["../../../src/features/syncTableManager/SyncTableManager.ts"],"sourcesContent":["import { KnexClient } from \"@webiny/api-core-sql\";\nimport { SyncTableManager as SyncTableManagerAbstraction } from \"./abstractions.js\";\nimport { TableNameResolver } from \"@webiny/api-headless-cms-sql/features/tableNameResolver/abstractions.js\";\n\nclass SyncTableManagerImpl implements SyncTableManagerAbstraction.Interface {\n    private readonly knex;\n    private readonly tableName;\n    private initialized = false;\n    private initPromise?: Promise<void>;\n\n    constructor(knex: KnexClient.Interface, tableNameResolver: TableNameResolver.Interface) {\n        this.knex = knex;\n        this.tableName = tableNameResolver.resolve(\"os_sync\");\n\n        const g = globalThis as Record<string, unknown>;\n        const managers = (g.__sqlTableManagers ??= []) as SyncTableManagerAbstraction.Interface[];\n        managers.push(this);\n    }\n\n    public reset(): void {\n        this.initialized = false;\n        this.initPromise = undefined;\n    }\n\n    public async ensureTable(): Promise<void> {\n        if (this.initialized) {\n            return;\n        }\n        if (!this.initPromise) {\n            this.initPromise = this.doEnsureTable().catch(err => {\n                this.initPromise = undefined;\n                throw err;\n            });\n        }\n        return this.initPromise;\n    }\n\n    public getTableName(): string {\n        return this.tableName;\n    }\n\n    private async doEnsureTable(): Promise<void> {\n        const exists = await this.knex.client.schema.hasTable(this.tableName);\n\n        if (!exists) {\n            await this.createTable();\n        }\n\n        this.initialized = true;\n    }\n\n    private async createTable(): Promise<void> {\n        try {\n            await this.knex.client.schema.createTable(this.tableName, table => {\n                table.text(\"id\").primary();\n                table.text(\"entryId\").notNullable();\n                table.text(\"index\").notNullable();\n                table.text(\"operation\").notNullable();\n                table.text(\"data\").notNullable();\n                table.text(\"tenant\").notNullable();\n\n                table.index([\"tenant\"]);\n            });\n        } catch (err) {\n            if (await this.knex.client.schema.hasTable(this.tableName)) {\n                return;\n            }\n            throw err;\n        }\n    }\n}\n\nexport const SyncTableManager = SyncTableManagerAbstraction.createImplementation({\n    implementation: SyncTableManagerImpl,\n    dependencies: [KnexClient, TableNameResolver]\n});\n"],"names":["SyncTableManagerImpl","knex","tableNameResolver","g","globalThis","managers","undefined","err","exists","table","SyncTableManager","SyncTableManagerAbstraction","KnexClient","TableNameResolver"],"mappings":";;;AAIA,MAAMA;IAMF,YAAYC,IAA0B,EAAEC,iBAA8C,CAAE;aAHhF,WAAW,GAAG;QAIlB,IAAI,CAAC,IAAI,GAAGD;QACZ,IAAI,CAAC,SAAS,GAAGC,kBAAkB,OAAO,CAAC;QAE3C,MAAMC,IAAIC;QACV,MAAMC,WAAYF,EAAE,kBAAkB,KAAK,EAAE;QAC7CE,SAAS,IAAI,CAAC,IAAI;IACtB;IAEO,QAAc;QACjB,IAAI,CAAC,WAAW,GAAG;QACnB,IAAI,CAAC,WAAW,GAAGC;IACvB;IAEA,MAAa,cAA6B;QACtC,IAAI,IAAI,CAAC,WAAW,EAChB;QAEJ,IAAI,CAAC,IAAI,CAAC,WAAW,EACjB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,GAAG,KAAK,CAACC,CAAAA;YAC1C,IAAI,CAAC,WAAW,GAAGD;YACnB,MAAMC;QACV;QAEJ,OAAO,IAAI,CAAC,WAAW;IAC3B;IAEO,eAAuB;QAC1B,OAAO,IAAI,CAAC,SAAS;IACzB;IAEA,MAAc,gBAA+B;QACzC,MAAMC,SAAS,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS;QAEpE,IAAI,CAACA,QACD,MAAM,IAAI,CAAC,WAAW;QAG1B,IAAI,CAAC,WAAW,GAAG;IACvB;IAEA,MAAc,cAA6B;QACvC,IAAI;YACA,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,EAAEC,CAAAA;gBACtDA,MAAM,IAAI,CAAC,MAAM,OAAO;gBACxBA,MAAM,IAAI,CAAC,WAAW,WAAW;gBACjCA,MAAM,IAAI,CAAC,SAAS,WAAW;gBAC/BA,MAAM,IAAI,CAAC,aAAa,WAAW;gBACnCA,MAAM,IAAI,CAAC,QAAQ,WAAW;gBAC9BA,MAAM,IAAI,CAAC,UAAU,WAAW;gBAEhCA,MAAM,KAAK,CAAC;oBAAC;iBAAS;YAC1B;QACJ,EAAE,OAAOF,KAAK;YACV,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,GACrD;YAEJ,MAAMA;QACV;IACJ;AACJ;AAEO,MAAMG,oCAAmBC,iBAAAA,oBAAgD,CAAC;IAC7E,gBAAgBX;IAChB,cAAc;QAACY;QAAYC;KAAkB;AACjD"}

package/features/syncTableManager/abstractions.d.ts

@@ -0,0 +1,9 @@
+export interface ISyncTableManager {
+    ensureTable(): Promise<void>;
+    getTableName(): string;
+    reset(): void;
+}
+export declare const SyncTableManager: import("@webiny/di").Abstraction<ISyncTableManager>;
+export declare namespace SyncTableManager {
+    type Interface = ISyncTableManager;
+}

package/features/syncTableManager/abstractions.js

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

package/features/syncTableManager/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/syncTableManager/abstractions.js","sources":["../../../src/features/syncTableManager/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api/index.js\";\n\nexport interface ISyncTableManager {\n    ensureTable(): Promise<void>;\n    getTableName(): string;\n    reset(): void;\n}\n\nexport const SyncTableManager = createAbstraction<ISyncTableManager>(\"Cms/PgOs/SyncTableManager\");\n\nexport namespace SyncTableManager {\n    export type Interface = ISyncTableManager;\n}\n"],"names":["SyncTableManager","createAbstraction"],"mappings":";AAQO,MAAMA,mBAAmBC,kBAAqC"}

package/features/syncTableManager/feature.d.ts

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

package/features/syncTableManager/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api/index.js";
+import { SyncTableManager } from "./SyncTableManager.js";
+const SyncTableManagerFeature = createFeature({
+    name: "cms.pgOs.syncTableManager",
+    register: (container)=>{
+        container.register(SyncTableManager).inSingletonScope();
+    }
+});
+export { SyncTableManagerFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/syncTableManager/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/syncTableManager/feature.js","sources":["../../../src/features/syncTableManager/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { SyncTableManager } from \"./SyncTableManager.js\";\n\nexport const SyncTableManagerFeature = createFeature({\n    name: \"cms.pgOs.syncTableManager\",\n    register: container => {\n        container.register(SyncTableManager).inSingletonScope();\n    }\n});\n"],"names":["SyncTableManagerFeature","createFeature","container","SyncTableManager"],"mappings":";;AAGO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC,kBAAkB,gBAAgB;IACzD;AACJ"}

package/index.d.ts

@@ -0,0 +1 @@
+export { HeadlessCmsPgOsFeature, type IPgOsStorageOperationsConfig } from "./features/HeadlessCmsPgOsFeature.js";

package/index.js

@@ -0,0 +1 @@
+export { HeadlessCmsPgOsFeature } from "./features/HeadlessCmsPgOsFeature.js";

package/operations/entry/EntrySearchOperations.d.ts

@@ -0,0 +1,15 @@
+import type { IEntrySearchOperations } from "./abstractions/EntrySearchOperations.js";
+import { OpenSearchClient } from "@webiny/api-opensearch/exports/api/opensearch.js";
+import { CmsEntryOpenSearchBodyBuilder, CmsEntryOpenSearchFieldIndexRegistry } from "@webiny/api-headless-cms-utils-os/exports/api/cms/opensearch.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { CmsStorageModelProvider } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+declare class EntrySearchOperationsImpl implements IEntrySearchOperations {
+    readonly list: IEntrySearchOperations["list"];
+    readonly get: IEntrySearchOperations["get"];
+    readonly getUniqueFieldValues: IEntrySearchOperations["getUniqueFieldValues"];
+    constructor(openSearchClient: OpenSearchClient.Interface, bodyBuilder: CmsEntryOpenSearchBodyBuilder.Interface, fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface, fieldIndexRegistry: CmsEntryOpenSearchFieldIndexRegistry.Interface, storageModelProvider: CmsStorageModelProvider.Interface);
+}
+export declare const EntrySearchOperations: typeof EntrySearchOperationsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IEntrySearchOperations>;
+};
+export {};