@webiny/api-headless-cms-sql 0.0.0-unstable.b6d7105cee → 6.6.0-alpha.1

package/features/entryTableManager/EntryTableManager.d.ts

@@ -5,9 +5,11 @@ declare class EntryTableManagerImpl implements EntryTableManagerAbstraction.Inte
     private readonly knex;
     private readonly tableName;
     private initialized;
+    private initPromise?;
     constructor(knex: KnexClient.Interface, tableNameResolver: TableNameResolver.Interface);
     reset(): void;
     ensureTable(): Promise<void>;
+    private doEnsureTable;
     getTableName(): string;
     private createTable;
 }

package/features/entryTableManager/EntryTableManager.js

@@ -12,9 +12,17 @@ class EntryTableManagerImpl {
     }
     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;
+    }
+    async doEnsureTable() {
         const exists = await this.knex.client.schema.hasTable(this.tableName);
         if (!exists) await this.createTable();
         this.initialized = true;
@@ -23,32 +31,37 @@ class EntryTableManagerImpl {
         return this.tableName;
     }
     async createTable() {
-        await this.knex.client.schema.createTable(this.tableName, (table)=>{
-            table.text("id").primary();
-            table.text("entryId").notNullable();
-            table.text("modelId").notNullable();
-            table.text("tenant").notNullable();
-            table.integer("version").notNullable();
-            table.boolean("isLatest").defaultTo(false);
-            table.boolean("isPublished").defaultTo(false);
-            table.boolean("wbyDeleted").defaultTo(false);
-            table.text("data").notNullable();
-            table.index([
-                "tenant",
-                "modelId",
-                "isLatest"
-            ]);
-            table.index([
-                "tenant",
-                "modelId",
-                "isPublished"
-            ]);
-            table.index([
-                "tenant",
-                "modelId",
-                "entryId"
-            ]);
-        });
+        try {
+            await this.knex.client.schema.createTable(this.tableName, (table)=>{
+                table.text("id").primary();
+                table.text("entryId").notNullable();
+                table.text("modelId").notNullable();
+                table.text("tenant").notNullable();
+                table.integer("version").notNullable();
+                table.boolean("isLatest").defaultTo(false);
+                table.boolean("isPublished").defaultTo(false);
+                table.boolean("wbyDeleted").defaultTo(false);
+                table.text("data").notNullable();
+                table.index([
+                    "tenant",
+                    "modelId",
+                    "isLatest"
+                ]);
+                table.index([
+                    "tenant",
+                    "modelId",
+                    "isPublished"
+                ]);
+                table.index([
+                    "tenant",
+                    "modelId",
+                    "entryId"
+                ]);
+            });
+        } catch (err) {
+            if (await this.knex.client.schema.hasTable(this.tableName)) return;
+            throw err;
+        }
     }
 }
 const EntryTableManager_EntryTableManager = EntryTableManager.createImplementation({

package/features/entryTableManager/EntryTableManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"features/entryTableManager/EntryTableManager.js","sources":["../../../src/features/entryTableManager/EntryTableManager.ts"],"sourcesContent":["import { KnexClient } from \"@webiny/api-core-sql\";\nimport { EntryTableManager as EntryTableManagerAbstraction } from \"./abstractions.js\";\nimport { TableNameResolver } from \"~/features/tableNameResolver/abstractions.js\";\n\nclass EntryTableManagerImpl implements EntryTableManagerAbstraction.Interface {\n    private readonly knex;\n    private readonly tableName;\n    private initialized = false;\n\n    constructor(knex: KnexClient.Interface, tableNameResolver: TableNameResolver.Interface) {\n        this.knex = knex;\n        this.tableName = tableNameResolver.resolve(\"entries\");\n\n        const g = globalThis as Record<string, unknown>;\n        const managers = (g.__sqlTableManagers ??= []) as EntryTableManagerAbstraction.Interface[];\n        managers.push(this);\n    }\n\n    public reset(): void {\n        this.initialized = false;\n    }\n\n    public async ensureTable(): Promise<void> {\n        if (this.initialized) {\n            return;\n        }\n\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    public getTableName(): string {\n        return this.tableName;\n    }\n\n    private async createTable(): Promise<void> {\n        await this.knex.client.schema.createTable(this.tableName, table => {\n            table.text(\"id\").primary();\n            table.text(\"entryId\").notNullable();\n            table.text(\"modelId\").notNullable();\n            table.text(\"tenant\").notNullable();\n            table.integer(\"version\").notNullable();\n            table.boolean(\"isLatest\").defaultTo(false);\n            table.boolean(\"isPublished\").defaultTo(false);\n            table.boolean(\"wbyDeleted\").defaultTo(false);\n            table.text(\"data\").notNullable();\n\n            table.index([\"tenant\", \"modelId\", \"isLatest\"]);\n            table.index([\"tenant\", \"modelId\", \"isPublished\"]);\n            table.index([\"tenant\", \"modelId\", \"entryId\"]);\n        });\n    }\n}\n\nexport const EntryTableManager = EntryTableManagerAbstraction.createImplementation({\n    implementation: EntryTableManagerImpl,\n    dependencies: [KnexClient, TableNameResolver]\n});\n"],"names":["EntryTableManagerImpl","knex","tableNameResolver","g","globalThis","managers","exists","table","EntryTableManager","EntryTableManagerAbstraction","KnexClient","TableNameResolver"],"mappings":";;;AAIA,MAAMA;IAKF,YAAYC,IAA0B,EAAEC,iBAA8C,CAAE;aAFhF,WAAW,GAAG;QAGlB,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;IACvB;IAEA,MAAa,cAA6B;QACtC,IAAI,IAAI,CAAC,WAAW,EAChB;QAGJ,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;IAEO,eAAuB;QAC1B,OAAO,IAAI,CAAC,SAAS;IACzB;IAEA,MAAc,cAA6B;QACvC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,SAAS,EAAEC,CAAAA;YACtDA,MAAM,IAAI,CAAC,MAAM,OAAO;YACxBA,MAAM,IAAI,CAAC,WAAW,WAAW;YACjCA,MAAM,IAAI,CAAC,WAAW,WAAW;YACjCA,MAAM,IAAI,CAAC,UAAU,WAAW;YAChCA,MAAM,OAAO,CAAC,WAAW,WAAW;YACpCA,MAAM,OAAO,CAAC,YAAY,SAAS,CAAC;YACpCA,MAAM,OAAO,CAAC,eAAe,SAAS,CAAC;YACvCA,MAAM,OAAO,CAAC,cAAc,SAAS,CAAC;YACtCA,MAAM,IAAI,CAAC,QAAQ,WAAW;YAE9BA,MAAM,KAAK,CAAC;gBAAC;gBAAU;gBAAW;aAAW;YAC7CA,MAAM,KAAK,CAAC;gBAAC;gBAAU;gBAAW;aAAc;YAChDA,MAAM,KAAK,CAAC;gBAAC;gBAAU;gBAAW;aAAU;QAChD;IACJ;AACJ;AAEO,MAAMC,sCAAoBC,kBAAAA,oBAAiD,CAAC;IAC/E,gBAAgBT;IAChB,cAAc;QAACU;QAAYC;KAAkB;AACjD"}
+{"version":3,"file":"features/entryTableManager/EntryTableManager.js","sources":["../../../src/features/entryTableManager/EntryTableManager.ts"],"sourcesContent":["import { KnexClient } from \"@webiny/api-core-sql\";\nimport { EntryTableManager as EntryTableManagerAbstraction } from \"./abstractions.js\";\nimport { TableNameResolver } from \"~/features/tableNameResolver/abstractions.js\";\n\nclass EntryTableManagerImpl implements EntryTableManagerAbstraction.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(\"entries\");\n\n        const g = globalThis as Record<string, unknown>;\n        const managers = (g.__sqlTableManagers ??= []) as EntryTableManagerAbstraction.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        // Memoize the in-flight init so concurrent callers (e.g. Promise.all entry creates) share a\n        // single hasTable+createTable and don't race into \"table already exists\". Clear on failure\n        // so a later call can retry.\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    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    public getTableName(): string {\n        return this.tableName;\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(\"modelId\").notNullable();\n                table.text(\"tenant\").notNullable();\n                table.integer(\"version\").notNullable();\n                table.boolean(\"isLatest\").defaultTo(false);\n                table.boolean(\"isPublished\").defaultTo(false);\n                table.boolean(\"wbyDeleted\").defaultTo(false);\n                table.text(\"data\").notNullable();\n\n                table.index([\"tenant\", \"modelId\", \"isLatest\"]);\n                table.index([\"tenant\", \"modelId\", \"isPublished\"]);\n                table.index([\"tenant\", \"modelId\", \"entryId\"]);\n            });\n        } catch (err) {\n            // The entries table is shared across all EntryTableManager instances (one per request\n            // container), so another instance/connection may create it concurrently. If it now\n            // exists, that's success; otherwise the failure is real.\n            if (await this.knex.client.schema.hasTable(this.tableName)) {\n                return;\n            }\n            throw err;\n        }\n    }\n}\n\nexport const EntryTableManager = EntryTableManagerAbstraction.createImplementation({\n    implementation: EntryTableManagerImpl,\n    dependencies: [KnexClient, TableNameResolver]\n});\n"],"names":["EntryTableManagerImpl","knex","tableNameResolver","g","globalThis","managers","undefined","err","exists","table","EntryTableManager","EntryTableManagerAbstraction","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;QAKJ,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;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;IAEO,eAAuB;QAC1B,OAAO,IAAI,CAAC,SAAS;IACzB;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,WAAW,WAAW;gBACjCA,MAAM,IAAI,CAAC,UAAU,WAAW;gBAChCA,MAAM,OAAO,CAAC,WAAW,WAAW;gBACpCA,MAAM,OAAO,CAAC,YAAY,SAAS,CAAC;gBACpCA,MAAM,OAAO,CAAC,eAAe,SAAS,CAAC;gBACvCA,MAAM,OAAO,CAAC,cAAc,SAAS,CAAC;gBACtCA,MAAM,IAAI,CAAC,QAAQ,WAAW;gBAE9BA,MAAM,KAAK,CAAC;oBAAC;oBAAU;oBAAW;iBAAW;gBAC7CA,MAAM,KAAK,CAAC;oBAAC;oBAAU;oBAAW;iBAAc;gBAChDA,MAAM,KAAK,CAAC;oBAAC;oBAAU;oBAAW;iBAAU;YAChD;QACJ,EAAE,OAAOF,KAAK;YAIV,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,GACrD;YAEJ,MAAMA;QACV;IACJ;AACJ;AAEO,MAAMG,sCAAoBC,kBAAAA,oBAAiD,CAAC;IAC/E,gBAAgBX;IAChB,cAAc;QAACY;QAAYC;KAAkB;AACjD"}

package/index.d.ts

@@ -4,5 +4,8 @@ interface ISqlStorageOperationsConfig {
     tableNamePrefix?: string;
     tableNameSuffix?: string;
 }
-export declare const registerSqlStorageOperations: (config: ISqlStorageOperationsConfig) => import("@webiny/handler").RegisterExtensionPlugin<import("@webiny/handler/types").Context>[];
+export declare const HeadlessCmsSqlFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container, context: ISqlStorageOperationsConfig): void;
+};
 export {};

package/index.js

@@ -1,81 +1,34 @@
-import { createGroupsStorageOperations } from "./operations/group/index.js";
-import { createModelsStorageOperations } from "./operations/model/index.js";
-import { createEntriesStorageOperations } from "./operations/entry/index.js";
-import { createRegisterExtensionPlugin } from "@webiny/handler";
 import { createFeature } from "@webiny/feature/api/index.js";
-import { StorageOperationsFactory } from "@webiny/api-headless-cms/exports/api/cms/storage.js";
 import { GroupSchemaManagerFeature } from "./features/groupSchemaManager/feature.js";
 import { ModelSchemaManagerFeature } from "./features/modelSchemaManager/feature.js";
 import { EntryTableManagerFeature } from "./features/entryTableManager/feature.js";
-import { GroupSchemaManager } from "./features/groupSchemaManager/abstractions.js";
-import { ModelSchemaManager } from "./features/modelSchemaManager/abstractions.js";
-import { EntryTableManager } from "./features/entryTableManager/abstractions.js";
-import { TableNameResolver, TableNameResolverConfig } from "./features/tableNameResolver/abstractions.js";
+import { TableNameResolverConfig } from "./features/tableNameResolver/abstractions.js";
 import { TableNameResolverFeature } from "./features/tableNameResolver/feature.js";
 import { ValueFilterFeature } from "@webiny/db-utils";
-import { createDatetimeTransformValuePlugin, createFilterCreatePlugins, createLocationFolderIdPathPlugin, createPlainObjectPathPlugin } from "@webiny/api-headless-cms-storage";
-import { KnexClient } from "@webiny/api-core-sql";
-const createSqlStorageOperations = (params)=>{
-    const { container, plugins } = params;
-    const knex = container.resolve(KnexClient);
-    const tableNameResolver = container.resolve(TableNameResolver);
-    const groupSchemaManager = container.resolve(GroupSchemaManager);
-    const modelSchemaManager = container.resolve(ModelSchemaManager);
-    const entryTableManager = container.resolve(EntryTableManager);
-    plugins.register([
-        createFilterCreatePlugins(),
-        createPlainObjectPathPlugin(),
-        createLocationFolderIdPathPlugin(),
-        createDatetimeTransformValuePlugin()
-    ]);
-    const groups = createGroupsStorageOperations(knex, tableNameResolver, groupSchemaManager);
-    const models = createModelsStorageOperations(knex, tableNameResolver, modelSchemaManager);
-    const entries = createEntriesStorageOperations({
-        knex,
-        entryTableManager,
-        container,
-        plugins
-    });
-    return {
-        name: "sql",
-        beforeInit: async ()=>{},
-        groups,
-        models,
-        entries
-    };
-};
-class SqlStorageOperationsFactoryImpl {
-    async create(context) {
-        return createSqlStorageOperations({
-            plugins: context.plugins,
-            container: context.container
+import { FilterRegistriesFeature } from "@webiny/api-headless-cms-storage";
+import { SqlGroupStorageOpsFeature } from "./operations/group/feature.js";
+import { SqlModelStorageOpsFeature } from "./operations/model/feature.js";
+import { SqlEntryStorageOpsFeature } from "./operations/entry/feature.js";
+const HeadlessCmsSqlFeature = createFeature({
+    name: "cms.storageOperations.sql",
+    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);
+        SqlGroupStorageOpsFeature.register(container);
+        SqlModelStorageOpsFeature.register(container);
+        SqlEntryStorageOpsFeature.register(container);
     }
-}
-const registerSqlStorageOperations = (config)=>{
-    const storageOperationsFeature = createFeature({
-        name: "cms.storageOperations.sql",
-        register: (container)=>{
-            const sharedTables = "true" === process.env.WEBINY_SHARED_TABLES;
-            container.registerInstance(TableNameResolverConfig, {
-                sharedTables,
-                tableNamePrefix: config.tableNamePrefix,
-                tableNameSuffix: config.tableNameSuffix
-            });
-            TableNameResolverFeature.register(container);
-            ValueFilterFeature.register(container);
-            GroupSchemaManagerFeature.register(container);
-            ModelSchemaManagerFeature.register(container);
-            EntryTableManagerFeature.register(container);
-            container.registerFactory(StorageOperationsFactory, ()=>new SqlStorageOperationsFactoryImpl());
-        }
-    });
-    const plugin = createRegisterExtensionPlugin((context)=>storageOperationsFeature.register(context.container));
-    plugin.name = "cms.registerSqlStorageOperations";
-    return [
-        plugin
-    ];
-};
-export { registerSqlStorageOperations };
+});
+export { HeadlessCmsSqlFeature };
 
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import type { CmsContext, SqlStorageOperationsFactory } from \"~/types.js\";\nimport { createGroupsStorageOperations } from \"~/operations/group/index.js\";\nimport { createModelsStorageOperations } from \"~/operations/model/index.js\";\nimport { createEntriesStorageOperations } from \"~/operations/entry/index.js\";\nimport { createRegisterExtensionPlugin } from \"@webiny/handler\";\nimport { createFeature } from \"@webiny/feature/api/index.js\";\nimport { StorageOperationsFactory as StorageOperationsFactoryAbstraction } from \"@webiny/api-headless-cms/exports/api/cms/storage.js\";\nimport { GroupSchemaManagerFeature } from \"~/features/groupSchemaManager/feature.js\";\nimport { ModelSchemaManagerFeature } from \"~/features/modelSchemaManager/feature.js\";\nimport { EntryTableManagerFeature } from \"~/features/entryTableManager/feature.js\";\nimport { GroupSchemaManager } from \"~/features/groupSchemaManager/abstractions.js\";\nimport { ModelSchemaManager } from \"~/features/modelSchemaManager/abstractions.js\";\nimport { EntryTableManager } from \"~/features/entryTableManager/abstractions.js\";\nimport { TableNameResolver } from \"~/features/tableNameResolver/abstractions.js\";\nimport { TableNameResolverConfig } from \"~/features/tableNameResolver/abstractions.js\";\nimport type { Knex } from \"knex\";\nimport { TableNameResolverFeature } from \"~/features/tableNameResolver/feature.js\";\nimport { ValueFilterFeature } from \"@webiny/db-utils\";\nimport {\n    createFilterCreatePlugins,\n    createPlainObjectPathPlugin,\n    createLocationFolderIdPathPlugin,\n    createDatetimeTransformValuePlugin\n} from \"@webiny/api-headless-cms-storage\";\nimport { KnexClient } from \"@webiny/api-core-sql\";\n\nconst createSqlStorageOperations: SqlStorageOperationsFactory = params => {\n    const { container, plugins } = params;\n\n    const knex = container.resolve(KnexClient);\n    const tableNameResolver = container.resolve(TableNameResolver);\n    const groupSchemaManager = container.resolve(GroupSchemaManager);\n    const modelSchemaManager = container.resolve(ModelSchemaManager);\n    const entryTableManager = container.resolve(EntryTableManager);\n\n    /* Register filter create plugins and field path plugins for in-memory filtering. */\n    plugins.register([\n        createFilterCreatePlugins(),\n        createPlainObjectPathPlugin(),\n        createLocationFolderIdPathPlugin(),\n        createDatetimeTransformValuePlugin()\n    ]);\n\n    const groups = createGroupsStorageOperations(knex, tableNameResolver, groupSchemaManager);\n\n    const models = createModelsStorageOperations(knex, tableNameResolver, modelSchemaManager);\n\n    const entries = createEntriesStorageOperations({\n        knex,\n        entryTableManager,\n        container,\n        plugins\n    });\n\n    return {\n        name: \"sql\",\n        beforeInit: async () => {\n            /* Schema managers handle table creation lazily on first access. */\n        },\n        groups,\n        models,\n        entries\n    };\n};\n\ninterface ISqlStorageOperationsConfig {\n    knex: Knex;\n    tableNamePrefix?: string;\n    tableNameSuffix?: string;\n}\n\nclass SqlStorageOperationsFactoryImpl implements StorageOperationsFactoryAbstraction.Interface {\n    public async create(context: CmsContext) {\n        return createSqlStorageOperations({\n            plugins: context.plugins,\n            container: context.container\n        });\n    }\n}\n\nexport const registerSqlStorageOperations = (config: ISqlStorageOperationsConfig) => {\n    const storageOperationsFeature = createFeature({\n        name: \"cms.storageOperations.sql\",\n        register: container => {\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            GroupSchemaManagerFeature.register(container);\n            ModelSchemaManagerFeature.register(container);\n            EntryTableManagerFeature.register(container);\n\n            container.registerFactory(StorageOperationsFactoryAbstraction, () => {\n                return new SqlStorageOperationsFactoryImpl();\n            });\n        }\n    });\n\n    const plugin = createRegisterExtensionPlugin(context => {\n        return storageOperationsFeature.register(context.container);\n    });\n\n    plugin.name = \"cms.registerSqlStorageOperations\";\n\n    return [plugin];\n};\n"],"names":["createSqlStorageOperations","params","container","plugins","knex","KnexClient","tableNameResolver","TableNameResolver","groupSchemaManager","GroupSchemaManager","modelSchemaManager","ModelSchemaManager","entryTableManager","EntryTableManager","createFilterCreatePlugins","createPlainObjectPathPlugin","createLocationFolderIdPathPlugin","createDatetimeTransformValuePlugin","groups","createGroupsStorageOperations","models","createModelsStorageOperations","entries","createEntriesStorageOperations","SqlStorageOperationsFactoryImpl","context","registerSqlStorageOperations","config","storageOperationsFeature","createFeature","sharedTables","process","TableNameResolverConfig","TableNameResolverFeature","ValueFilterFeature","GroupSchemaManagerFeature","ModelSchemaManagerFeature","EntryTableManagerFeature","StorageOperationsFactoryAbstraction","plugin","createRegisterExtensionPlugin"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,MAAMA,6BAA0DC,CAAAA;IAC5D,MAAM,EAAEC,SAAS,EAAEC,OAAO,EAAE,GAAGF;IAE/B,MAAMG,OAAOF,UAAU,OAAO,CAACG;IAC/B,MAAMC,oBAAoBJ,UAAU,OAAO,CAACK;IAC5C,MAAMC,qBAAqBN,UAAU,OAAO,CAACO;IAC7C,MAAMC,qBAAqBR,UAAU,OAAO,CAACS;IAC7C,MAAMC,oBAAoBV,UAAU,OAAO,CAACW;IAG5CV,QAAQ,QAAQ,CAAC;QACbW;QACAC;QACAC;QACAC;KACH;IAED,MAAMC,SAASC,8BAA8Bf,MAAME,mBAAmBE;IAEtE,MAAMY,SAASC,8BAA8BjB,MAAME,mBAAmBI;IAEtE,MAAMY,UAAUC,+BAA+B;QAC3CnB;QACAQ;QACAV;QACAC;IACJ;IAEA,OAAO;QACH,MAAM;QACN,YAAY,WAEZ;QACAe;QACAE;QACAE;IACJ;AACJ;AAQA,MAAME;IACF,MAAa,OAAOC,OAAmB,EAAE;QACrC,OAAOzB,2BAA2B;YAC9B,SAASyB,QAAQ,OAAO;YACxB,WAAWA,QAAQ,SAAS;QAChC;IACJ;AACJ;AAEO,MAAMC,+BAA+B,CAACC;IACzC,MAAMC,2BAA2BC,cAAc;QAC3C,MAAM;QACN,UAAU3B,CAAAA;YACN,MAAM4B,eAAeC,AAAqC,WAArCA,QAAQ,GAAG,CAAC,oBAAoB;YAErD7B,UAAU,gBAAgB,CAAC8B,yBAAyB;gBAChDF;gBACA,iBAAiBH,OAAO,eAAe;gBACvC,iBAAiBA,OAAO,eAAe;YAC3C;YAEAM,yBAAyB,QAAQ,CAAC/B;YAClCgC,mBAAmB,QAAQ,CAAChC;YAC5BiC,0BAA0B,QAAQ,CAACjC;YACnCkC,0BAA0B,QAAQ,CAAClC;YACnCmC,yBAAyB,QAAQ,CAACnC;YAElCA,UAAU,eAAe,CAACoC,0BAAqC,IACpD,IAAId;QAEnB;IACJ;IAEA,MAAMe,SAASC,8BAA8Bf,CAAAA,UAClCG,yBAAyB,QAAQ,CAACH,QAAQ,SAAS;IAG9Dc,OAAO,IAAI,GAAG;IAEd,OAAO;QAACA;KAAO;AACnB"}
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api/index.js\";\nimport { GroupSchemaManagerFeature } from \"~/features/groupSchemaManager/feature.js\";\nimport { ModelSchemaManagerFeature } from \"~/features/modelSchemaManager/feature.js\";\nimport { EntryTableManagerFeature } from \"~/features/entryTableManager/feature.js\";\nimport { TableNameResolverConfig } from \"~/features/tableNameResolver/abstractions.js\";\nimport type { Knex } from \"knex\";\nimport { TableNameResolverFeature } from \"~/features/tableNameResolver/feature.js\";\nimport { ValueFilterFeature } from \"@webiny/db-utils\";\nimport { FilterRegistriesFeature } from \"@webiny/api-headless-cms-storage\";\nimport { SqlGroupStorageOpsFeature } from \"~/operations/group/feature.js\";\nimport { SqlModelStorageOpsFeature } from \"~/operations/model/feature.js\";\nimport { SqlEntryStorageOpsFeature } from \"~/operations/entry/feature.js\";\n\ninterface ISqlStorageOperationsConfig {\n    knex: Knex;\n    tableNamePrefix?: string;\n    tableNameSuffix?: string;\n}\n\nexport const HeadlessCmsSqlFeature = createFeature<ISqlStorageOperationsConfig>({\n    name: \"cms.storageOperations.sql\",\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\n        SqlGroupStorageOpsFeature.register(container);\n        SqlModelStorageOpsFeature.register(container);\n        SqlEntryStorageOpsFeature.register(container);\n    }\n});\n"],"names":["HeadlessCmsSqlFeature","createFeature","container","config","sharedTables","process","TableNameResolverConfig","TableNameResolverFeature","ValueFilterFeature","FilterRegistriesFeature","GroupSchemaManagerFeature","ModelSchemaManagerFeature","EntryTableManagerFeature","SqlGroupStorageOpsFeature","SqlModelStorageOpsFeature","SqlEntryStorageOpsFeature"],"mappings":";;;;;;;;;;;AAmBO,MAAMA,wBAAwBC,cAA2C;IAC5E,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;QAElCW,0BAA0B,QAAQ,CAACX;QACnCY,0BAA0B,QAAQ,CAACZ;QACnCa,0BAA0B,QAAQ,CAACb;IACvC;AACJ"}

package/operations/entry/SqlCreateEntry.d.ts

@@ -0,0 +1,15 @@
+import type { CmsEntryStorageOperationsCreateParams, CmsEntryValues, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { CreateEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+declare class SqlCreateEntryImpl implements CreateEntryStorageOperation.Interface {
+    private readonly entryTableManager;
+    private readonly knex;
+    constructor(knexClient: KnexClient.Interface, entryTableManager: EntryTableManager.Interface);
+    private query;
+    execute<T extends CmsEntryValues>(_model: CmsModel, params: CmsEntryStorageOperationsCreateParams<T>): Promise<import("@webiny/api-headless-cms/types/types.js").CmsStorageEntry<T>>;
+}
+export declare const SqlCreateEntry: typeof SqlCreateEntryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js").ICreateEntryStorageOperation>;
+};
+export {};

package/operations/entry/SqlCreateEntry.js

@@ -0,0 +1,35 @@
+import { CreateEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+import { entryToRow } from "./mappers.js";
+import { createEntryQuery } from "./queryHelpers.js";
+class SqlCreateEntryImpl {
+    constructor(knexClient, entryTableManager){
+        this.entryTableManager = entryTableManager;
+        this.knex = knexClient.client;
+    }
+    query() {
+        return createEntryQuery(this.knex, this.entryTableManager.getTableName());
+    }
+    async execute(_model, params) {
+        await this.entryTableManager.ensureTable();
+        const storageEntry = structuredClone(params.storageEntry);
+        storageEntry.isLatest = true;
+        storageEntry.isPublished = "published" === storageEntry.status;
+        const row = entryToRow(storageEntry);
+        await this.query().insert(row);
+        delete storageEntry.isLatest;
+        delete storageEntry.isPublished;
+        return storageEntry;
+    }
+}
+const SqlCreateEntry = CreateEntryStorageOperation.createImplementation({
+    implementation: SqlCreateEntryImpl,
+    dependencies: [
+        KnexClient,
+        EntryTableManager
+    ]
+});
+export { SqlCreateEntry };
+
+//# sourceMappingURL=SqlCreateEntry.js.map

package/operations/entry/SqlCreateEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/SqlCreateEntry.js","sources":["../../../src/operations/entry/SqlCreateEntry.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport type {\n    CmsEntryStorageOperationsCreateParams,\n    CmsEntryValues,\n    CmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { CreateEntryStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryStorageOperation.js\";\nimport { KnexClient } from \"@webiny/api-core-sql\";\nimport { EntryTableManager } from \"~/features/entryTableManager/abstractions.js\";\nimport type { IEntryRow } from \"./types.js\";\nimport { entryToRow } from \"./mappers.js\";\nimport { createEntryQuery } from \"./queryHelpers.js\";\n\nclass SqlCreateEntryImpl implements CreateEntryStorageOperation.Interface {\n    private readonly knex: Knex;\n\n    public constructor(\n        knexClient: KnexClient.Interface,\n        private readonly entryTableManager: EntryTableManager.Interface\n    ) {\n        this.knex = knexClient.client;\n    }\n\n    private query(): Knex.QueryBuilder<IEntryRow> {\n        return createEntryQuery(this.knex, this.entryTableManager.getTableName());\n    }\n\n    async execute<T extends CmsEntryValues>(\n        _model: CmsModel,\n        params: CmsEntryStorageOperationsCreateParams<T>\n    ) {\n        await this.entryTableManager.ensureTable();\n\n        const storageEntry = structuredClone(params.storageEntry);\n        storageEntry.isLatest = true;\n        storageEntry.isPublished = storageEntry.status === \"published\";\n\n        const row = entryToRow(storageEntry);\n        await this.query().insert(row);\n\n        delete storageEntry.isLatest;\n        delete storageEntry.isPublished;\n        return storageEntry;\n    }\n}\n\nexport const SqlCreateEntry = CreateEntryStorageOperation.createImplementation({\n    implementation: SqlCreateEntryImpl,\n    dependencies: [KnexClient, EntryTableManager]\n});\n"],"names":["SqlCreateEntryImpl","knexClient","entryTableManager","createEntryQuery","_model","params","storageEntry","structuredClone","row","entryToRow","SqlCreateEntry","CreateEntryStorageOperation","KnexClient","EntryTableManager"],"mappings":";;;;;AAaA,MAAMA;IAGF,YACIC,UAAgC,EACfC,iBAA8C,CACjE;aADmBA,iBAAiB,GAAjBA;QAEjB,IAAI,CAAC,IAAI,GAAGD,WAAW,MAAM;IACjC;IAEQ,QAAsC;QAC1C,OAAOE,iBAAiB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,YAAY;IAC1E;IAEA,MAAM,QACFC,MAAgB,EAChBC,MAAgD,EAClD;QACE,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW;QAExC,MAAMC,eAAeC,gBAAgBF,OAAO,YAAY;QACxDC,aAAa,QAAQ,GAAG;QACxBA,aAAa,WAAW,GAAGA,AAAwB,gBAAxBA,aAAa,MAAM;QAE9C,MAAME,MAAMC,WAAWH;QACvB,MAAM,IAAI,CAAC,KAAK,GAAG,MAAM,CAACE;QAE1B,OAAOF,aAAa,QAAQ;QAC5B,OAAOA,aAAa,WAAW;QAC/B,OAAOA;IACX;AACJ;AAEO,MAAMI,iBAAiBC,4BAA4B,oBAAoB,CAAC;IAC3E,gBAAgBX;IAChB,cAAc;QAACY;QAAYC;KAAkB;AACjD"}

package/operations/entry/SqlCreateEntryRevisionFrom.d.ts

@@ -0,0 +1,15 @@
+import type { CmsEntryStorageOperationsCreateRevisionFromParams, CmsEntryValues, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { CreateEntryRevisionFromStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+declare class SqlCreateEntryRevisionFromImpl implements CreateEntryRevisionFromStorageOperation.Interface {
+    private readonly entryTableManager;
+    private readonly knex;
+    constructor(knexClient: KnexClient.Interface, entryTableManager: EntryTableManager.Interface);
+    private query;
+    execute<T extends CmsEntryValues>(model: CmsModel, params: CmsEntryStorageOperationsCreateRevisionFromParams<T>): Promise<import("@webiny/api-headless-cms/types/types.js").CmsEntry<T>>;
+}
+export declare const SqlCreateEntryRevisionFrom: typeof SqlCreateEntryRevisionFromImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js").ICreateEntryRevisionFromStorageOperation>;
+};
+export {};

package/operations/entry/SqlCreateEntryRevisionFrom.js

@@ -0,0 +1,55 @@
+import { CreateEntryRevisionFromStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+import { entryToRow } from "./mappers.js";
+import { createEntryQuery } from "./queryHelpers.js";
+class SqlCreateEntryRevisionFromImpl {
+    constructor(knexClient, entryTableManager){
+        this.entryTableManager = entryTableManager;
+        this.knex = knexClient.client;
+    }
+    query() {
+        return createEntryQuery(this.knex, this.entryTableManager.getTableName());
+    }
+    async execute(model, params) {
+        await this.entryTableManager.ensureTable();
+        const isPublished = "published" === params.entry.status;
+        const oldLatestRows = await this.query().where("tenant", model.tenant).andWhere("entryId", params.entry.entryId).andWhere("isLatest", true);
+        for (const row of oldLatestRows){
+            const parsed = JSON.parse(row.data);
+            parsed.isLatest = false;
+            await this.query().where("id", row.id).update({
+                isLatest: false,
+                data: JSON.stringify(parsed)
+            });
+        }
+        if (isPublished) {
+            const oldPublishedRows = await this.query().where("tenant", model.tenant).andWhere("entryId", params.entry.entryId).andWhere("isPublished", true);
+            for (const row of oldPublishedRows){
+                const parsed = JSON.parse(row.data);
+                parsed.isPublished = false;
+                parsed.status = "unpublished";
+                await this.query().where("id", row.id).update({
+                    isPublished: false,
+                    data: JSON.stringify(parsed)
+                });
+            }
+        }
+        const se = params.storageEntry;
+        se.isLatest = true;
+        se.isPublished = isPublished;
+        const row = entryToRow(se);
+        await this.query().insert(row);
+        return params.entry;
+    }
+}
+const SqlCreateEntryRevisionFrom = CreateEntryRevisionFromStorageOperation.createImplementation({
+    implementation: SqlCreateEntryRevisionFromImpl,
+    dependencies: [
+        KnexClient,
+        EntryTableManager
+    ]
+});
+export { SqlCreateEntryRevisionFrom };
+
+//# sourceMappingURL=SqlCreateEntryRevisionFrom.js.map

package/operations/entry/SqlCreateEntryRevisionFrom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/SqlCreateEntryRevisionFrom.js","sources":["../../../src/operations/entry/SqlCreateEntryRevisionFrom.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport type {\n    CmsEntryStorageOperationsCreateRevisionFromParams,\n    CmsEntryValues,\n    CmsModel,\n    CmsStorageEntry\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { CreateEntryRevisionFromStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/CreateEntryRevisionFromStorageOperation.js\";\nimport { KnexClient } from \"@webiny/api-core-sql\";\nimport { EntryTableManager } from \"~/features/entryTableManager/abstractions.js\";\nimport type { IEntryRow } from \"./types.js\";\nimport { entryToRow } from \"./mappers.js\";\nimport { createEntryQuery } from \"./queryHelpers.js\";\n\nclass SqlCreateEntryRevisionFromImpl implements CreateEntryRevisionFromStorageOperation.Interface {\n    private readonly knex: Knex;\n\n    public constructor(\n        knexClient: KnexClient.Interface,\n        private readonly entryTableManager: EntryTableManager.Interface\n    ) {\n        this.knex = knexClient.client;\n    }\n\n    private query(): Knex.QueryBuilder<IEntryRow> {\n        return createEntryQuery(this.knex, this.entryTableManager.getTableName());\n    }\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        params: CmsEntryStorageOperationsCreateRevisionFromParams<T>\n    ) {\n        await this.entryTableManager.ensureTable();\n\n        const isPublished = params.entry.status === \"published\";\n\n        const oldLatestRows = await this.query()\n            .where(\"tenant\", model.tenant)\n            .andWhere(\"entryId\", params.entry.entryId)\n            .andWhere(\"isLatest\", true);\n\n        for (const row of oldLatestRows) {\n            const parsed = JSON.parse(row.data);\n            parsed.isLatest = false;\n\n            await this.query()\n                .where(\"id\", row.id)\n                .update({ isLatest: false, data: JSON.stringify(parsed) });\n        }\n\n        if (isPublished) {\n            const oldPublishedRows = await this.query()\n                .where(\"tenant\", model.tenant)\n                .andWhere(\"entryId\", params.entry.entryId)\n                .andWhere(\"isPublished\", true);\n\n            for (const row of oldPublishedRows) {\n                const parsed = JSON.parse(row.data);\n                parsed.isPublished = false;\n                parsed.status = \"unpublished\";\n\n                await this.query()\n                    .where(\"id\", row.id)\n                    .update({ isPublished: false, data: JSON.stringify(parsed) });\n            }\n        }\n\n        const se = params.storageEntry as CmsStorageEntry;\n        se.isLatest = true;\n        se.isPublished = isPublished;\n\n        const row = entryToRow(se);\n        await this.query().insert(row);\n\n        return params.entry;\n    }\n}\n\nexport const SqlCreateEntryRevisionFrom =\n    CreateEntryRevisionFromStorageOperation.createImplementation({\n        implementation: SqlCreateEntryRevisionFromImpl,\n        dependencies: [KnexClient, EntryTableManager]\n    });\n"],"names":["SqlCreateEntryRevisionFromImpl","knexClient","entryTableManager","createEntryQuery","model","params","isPublished","oldLatestRows","row","parsed","JSON","oldPublishedRows","se","entryToRow","SqlCreateEntryRevisionFrom","CreateEntryRevisionFromStorageOperation","KnexClient","EntryTableManager"],"mappings":";;;;;AAcA,MAAMA;IAGF,YACIC,UAAgC,EACfC,iBAA8C,CACjE;aADmBA,iBAAiB,GAAjBA;QAEjB,IAAI,CAAC,IAAI,GAAGD,WAAW,MAAM;IACjC;IAEQ,QAAsC;QAC1C,OAAOE,iBAAiB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,YAAY;IAC1E;IAEA,MAAM,QACFC,KAAe,EACfC,MAA4D,EAC9D;QACE,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW;QAExC,MAAMC,cAAcD,AAAwB,gBAAxBA,OAAO,KAAK,CAAC,MAAM;QAEvC,MAAME,gBAAgB,MAAM,IAAI,CAAC,KAAK,GACjC,KAAK,CAAC,UAAUH,MAAM,MAAM,EAC5B,QAAQ,CAAC,WAAWC,OAAO,KAAK,CAAC,OAAO,EACxC,QAAQ,CAAC,YAAY;QAE1B,KAAK,MAAMG,OAAOD,cAAe;YAC7B,MAAME,SAASC,KAAK,KAAK,CAACF,IAAI,IAAI;YAClCC,OAAO,QAAQ,GAAG;YAElB,MAAM,IAAI,CAAC,KAAK,GACX,KAAK,CAAC,MAAMD,IAAI,EAAE,EAClB,MAAM,CAAC;gBAAE,UAAU;gBAAO,MAAME,KAAK,SAAS,CAACD;YAAQ;QAChE;QAEA,IAAIH,aAAa;YACb,MAAMK,mBAAmB,MAAM,IAAI,CAAC,KAAK,GACpC,KAAK,CAAC,UAAUP,MAAM,MAAM,EAC5B,QAAQ,CAAC,WAAWC,OAAO,KAAK,CAAC,OAAO,EACxC,QAAQ,CAAC,eAAe;YAE7B,KAAK,MAAMG,OAAOG,iBAAkB;gBAChC,MAAMF,SAASC,KAAK,KAAK,CAACF,IAAI,IAAI;gBAClCC,OAAO,WAAW,GAAG;gBACrBA,OAAO,MAAM,GAAG;gBAEhB,MAAM,IAAI,CAAC,KAAK,GACX,KAAK,CAAC,MAAMD,IAAI,EAAE,EAClB,MAAM,CAAC;oBAAE,aAAa;oBAAO,MAAME,KAAK,SAAS,CAACD;gBAAQ;YACnE;QACJ;QAEA,MAAMG,KAAKP,OAAO,YAAY;QAC9BO,GAAG,QAAQ,GAAG;QACdA,GAAG,WAAW,GAAGN;QAEjB,MAAME,MAAMK,WAAWD;QACvB,MAAM,IAAI,CAAC,KAAK,GAAG,MAAM,CAACJ;QAE1B,OAAOH,OAAO,KAAK;IACvB;AACJ;AAEO,MAAMS,6BACTC,wCAAwC,oBAAoB,CAAC;IACzD,gBAAgBf;IAChB,cAAc;QAACgB;QAAYC;KAAkB;AACjD"}

package/operations/entry/SqlDeleteEntry.d.ts

@@ -0,0 +1,15 @@
+import type { CmsEntryStorageOperationsDeleteParams, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { DeleteEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+declare class SqlDeleteEntryImpl implements DeleteEntryStorageOperation.Interface {
+    private readonly entryTableManager;
+    private readonly knex;
+    constructor(knexClient: KnexClient.Interface, entryTableManager: EntryTableManager.Interface);
+    private query;
+    execute(model: CmsModel, params: CmsEntryStorageOperationsDeleteParams): Promise<void>;
+}
+export declare const SqlDeleteEntry: typeof SqlDeleteEntryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js").IDeleteEntryStorageOperation>;
+};
+export {};

package/operations/entry/SqlDeleteEntry.js

@@ -0,0 +1,29 @@
+import { DeleteEntryStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+import { parseIdentifier } from "@webiny/utils";
+import { createEntryQuery } from "./queryHelpers.js";
+class SqlDeleteEntryImpl {
+    constructor(knexClient, entryTableManager){
+        this.entryTableManager = entryTableManager;
+        this.knex = knexClient.client;
+    }
+    query() {
+        return createEntryQuery(this.knex, this.entryTableManager.getTableName());
+    }
+    async execute(model, params) {
+        await this.entryTableManager.ensureTable();
+        const { id: entryId } = parseIdentifier(params.entry.id);
+        await this.query().where("tenant", model.tenant).andWhere("entryId", entryId).delete();
+    }
+}
+const SqlDeleteEntry = DeleteEntryStorageOperation.createImplementation({
+    implementation: SqlDeleteEntryImpl,
+    dependencies: [
+        KnexClient,
+        EntryTableManager
+    ]
+});
+export { SqlDeleteEntry };
+
+//# sourceMappingURL=SqlDeleteEntry.js.map

package/operations/entry/SqlDeleteEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/SqlDeleteEntry.js","sources":["../../../src/operations/entry/SqlDeleteEntry.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport type {\n    CmsEntryStorageOperationsDeleteParams,\n    CmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { DeleteEntryStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryStorageOperation.js\";\nimport { KnexClient } from \"@webiny/api-core-sql\";\nimport { EntryTableManager } from \"~/features/entryTableManager/abstractions.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport type { IEntryRow } from \"./types.js\";\nimport { createEntryQuery } from \"./queryHelpers.js\";\n\nclass SqlDeleteEntryImpl implements DeleteEntryStorageOperation.Interface {\n    private readonly knex: Knex;\n\n    public constructor(\n        knexClient: KnexClient.Interface,\n        private readonly entryTableManager: EntryTableManager.Interface\n    ) {\n        this.knex = knexClient.client;\n    }\n\n    private query(): Knex.QueryBuilder<IEntryRow> {\n        return createEntryQuery(this.knex, this.entryTableManager.getTableName());\n    }\n\n    async execute(model: CmsModel, params: CmsEntryStorageOperationsDeleteParams) {\n        await this.entryTableManager.ensureTable();\n\n        const { id: entryId } = parseIdentifier(params.entry.id);\n\n        await this.query().where(\"tenant\", model.tenant).andWhere(\"entryId\", entryId).delete();\n    }\n}\n\nexport const SqlDeleteEntry = DeleteEntryStorageOperation.createImplementation({\n    implementation: SqlDeleteEntryImpl,\n    dependencies: [KnexClient, EntryTableManager]\n});\n"],"names":["SqlDeleteEntryImpl","knexClient","entryTableManager","createEntryQuery","model","params","entryId","parseIdentifier","SqlDeleteEntry","DeleteEntryStorageOperation","KnexClient","EntryTableManager"],"mappings":";;;;;AAYA,MAAMA;IAGF,YACIC,UAAgC,EACfC,iBAA8C,CACjE;aADmBA,iBAAiB,GAAjBA;QAEjB,IAAI,CAAC,IAAI,GAAGD,WAAW,MAAM;IACjC;IAEQ,QAAsC;QAC1C,OAAOE,iBAAiB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,YAAY;IAC1E;IAEA,MAAM,QAAQC,KAAe,EAAEC,MAA6C,EAAE;QAC1E,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW;QAExC,MAAM,EAAE,IAAIC,OAAO,EAAE,GAAGC,gBAAgBF,OAAO,KAAK,CAAC,EAAE;QAEvD,MAAM,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,UAAUD,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAWE,SAAS,MAAM;IACxF;AACJ;AAEO,MAAME,iBAAiBC,4BAA4B,oBAAoB,CAAC;IAC3E,gBAAgBT;IAChB,cAAc;QAACU;QAAYC;KAAkB;AACjD"}

package/operations/entry/SqlDeleteEntryRevision.d.ts

@@ -0,0 +1,15 @@
+import type { CmsEntryStorageOperationsDeleteRevisionParams, CmsEntryValues, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { DeleteEntryRevisionStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryRevisionStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+declare class SqlDeleteEntryRevisionImpl implements DeleteEntryRevisionStorageOperation.Interface {
+    private readonly entryTableManager;
+    private readonly knex;
+    constructor(knexClient: KnexClient.Interface, entryTableManager: EntryTableManager.Interface);
+    private query;
+    execute<T extends CmsEntryValues>(model: CmsModel, params: CmsEntryStorageOperationsDeleteRevisionParams<T>): Promise<void>;
+}
+export declare const SqlDeleteEntryRevision: typeof SqlDeleteEntryRevisionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryRevisionStorageOperation.js").IDeleteEntryRevisionStorageOperation>;
+};
+export {};

package/operations/entry/SqlDeleteEntryRevision.js

@@ -0,0 +1,39 @@
+import { DeleteEntryRevisionStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryRevisionStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+import { entryToRow } from "./mappers.js";
+import { createEntryQuery, patchAllEntryRevisions } from "./queryHelpers.js";
+class SqlDeleteEntryRevisionImpl {
+    constructor(knexClient, entryTableManager){
+        this.entryTableManager = entryTableManager;
+        this.knex = knexClient.client;
+    }
+    query() {
+        return createEntryQuery(this.knex, this.entryTableManager.getTableName());
+    }
+    async execute(model, params) {
+        await this.entryTableManager.ensureTable();
+        const wasPublished = "published" === params.storageEntry.status;
+        await this.query().where("tenant", model.tenant).andWhere("id", params.storageEntry.id).delete();
+        if (wasPublished) await patchAllEntryRevisions(this.knex, this.entryTableManager.getTableName(), params.storageEntry.entryId, model.tenant, (parsed)=>{
+            parsed.live = null;
+        });
+        if (params.latestStorageEntry) {
+            const latestParsed = structuredClone(params.latestStorageEntry);
+            latestParsed.isLatest = true;
+            if (wasPublished) latestParsed.live = null;
+            const latestRow = entryToRow(latestParsed);
+            await this.query().where("tenant", model.tenant).andWhere("id", params.latestStorageEntry.id).update(latestRow);
+        }
+    }
+}
+const SqlDeleteEntryRevision = DeleteEntryRevisionStorageOperation.createImplementation({
+    implementation: SqlDeleteEntryRevisionImpl,
+    dependencies: [
+        KnexClient,
+        EntryTableManager
+    ]
+});
+export { SqlDeleteEntryRevision };
+
+//# sourceMappingURL=SqlDeleteEntryRevision.js.map

package/operations/entry/SqlDeleteEntryRevision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/SqlDeleteEntryRevision.js","sources":["../../../src/operations/entry/SqlDeleteEntryRevision.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport type {\n    CmsEntryStorageOperationsDeleteRevisionParams,\n    CmsEntryValues,\n    CmsModel,\n    CmsStorageEntry\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { DeleteEntryRevisionStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteEntryRevisionStorageOperation.js\";\nimport { KnexClient } from \"@webiny/api-core-sql\";\nimport { EntryTableManager } from \"~/features/entryTableManager/abstractions.js\";\nimport type { IEntryRow } from \"./types.js\";\nimport { entryToRow } from \"./mappers.js\";\nimport { createEntryQuery, patchAllEntryRevisions } from \"./queryHelpers.js\";\n\nclass SqlDeleteEntryRevisionImpl implements DeleteEntryRevisionStorageOperation.Interface {\n    private readonly knex: Knex;\n\n    public constructor(\n        knexClient: KnexClient.Interface,\n        private readonly entryTableManager: EntryTableManager.Interface\n    ) {\n        this.knex = knexClient.client;\n    }\n\n    private query(): Knex.QueryBuilder<IEntryRow> {\n        return createEntryQuery(this.knex, this.entryTableManager.getTableName());\n    }\n\n    async execute<T extends CmsEntryValues>(\n        model: CmsModel,\n        params: CmsEntryStorageOperationsDeleteRevisionParams<T>\n    ) {\n        await this.entryTableManager.ensureTable();\n\n        const wasPublished = params.storageEntry.status === \"published\";\n\n        await this.query()\n            .where(\"tenant\", model.tenant)\n            .andWhere(\"id\", params.storageEntry.id)\n            .delete();\n\n        if (wasPublished) {\n            await patchAllEntryRevisions(\n                this.knex,\n                this.entryTableManager.getTableName(),\n                params.storageEntry.entryId,\n                model.tenant,\n                parsed => {\n                    parsed.live = null;\n                }\n            );\n        }\n\n        if (params.latestStorageEntry) {\n            const latestParsed = structuredClone(params.latestStorageEntry);\n            latestParsed.isLatest = true;\n\n            if (wasPublished) {\n                latestParsed.live = null;\n            }\n\n            const latestRow = entryToRow(latestParsed as CmsStorageEntry);\n\n            await this.query()\n                .where(\"tenant\", model.tenant)\n                .andWhere(\"id\", params.latestStorageEntry.id)\n                .update(latestRow);\n        }\n    }\n}\n\nexport const SqlDeleteEntryRevision = DeleteEntryRevisionStorageOperation.createImplementation({\n    implementation: SqlDeleteEntryRevisionImpl,\n    dependencies: [KnexClient, EntryTableManager]\n});\n"],"names":["SqlDeleteEntryRevisionImpl","knexClient","entryTableManager","createEntryQuery","model","params","wasPublished","patchAllEntryRevisions","parsed","latestParsed","structuredClone","latestRow","entryToRow","SqlDeleteEntryRevision","DeleteEntryRevisionStorageOperation","KnexClient","EntryTableManager"],"mappings":";;;;;AAcA,MAAMA;IAGF,YACIC,UAAgC,EACfC,iBAA8C,CACjE;aADmBA,iBAAiB,GAAjBA;QAEjB,IAAI,CAAC,IAAI,GAAGD,WAAW,MAAM;IACjC;IAEQ,QAAsC;QAC1C,OAAOE,iBAAiB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,YAAY;IAC1E;IAEA,MAAM,QACFC,KAAe,EACfC,MAAwD,EAC1D;QACE,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW;QAExC,MAAMC,eAAeD,AAA+B,gBAA/BA,OAAO,YAAY,CAAC,MAAM;QAE/C,MAAM,IAAI,CAAC,KAAK,GACX,KAAK,CAAC,UAAUD,MAAM,MAAM,EAC5B,QAAQ,CAAC,MAAMC,OAAO,YAAY,CAAC,EAAE,EACrC,MAAM;QAEX,IAAIC,cACA,MAAMC,uBACF,IAAI,CAAC,IAAI,EACT,IAAI,CAAC,iBAAiB,CAAC,YAAY,IACnCF,OAAO,YAAY,CAAC,OAAO,EAC3BD,MAAM,MAAM,EACZI,CAAAA;YACIA,OAAO,IAAI,GAAG;QAClB;QAIR,IAAIH,OAAO,kBAAkB,EAAE;YAC3B,MAAMI,eAAeC,gBAAgBL,OAAO,kBAAkB;YAC9DI,aAAa,QAAQ,GAAG;YAExB,IAAIH,cACAG,aAAa,IAAI,GAAG;YAGxB,MAAME,YAAYC,WAAWH;YAE7B,MAAM,IAAI,CAAC,KAAK,GACX,KAAK,CAAC,UAAUL,MAAM,MAAM,EAC5B,QAAQ,CAAC,MAAMC,OAAO,kBAAkB,CAAC,EAAE,EAC3C,MAAM,CAACM;QAChB;IACJ;AACJ;AAEO,MAAME,yBAAyBC,oCAAoC,oBAAoB,CAAC;IAC3F,gBAAgBd;IAChB,cAAc;QAACe;QAAYC;KAAkB;AACjD"}

package/operations/entry/SqlDeleteMultipleEntries.d.ts

@@ -0,0 +1,15 @@
+import type { CmsEntryStorageOperationsDeleteEntriesParams, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { DeleteMultipleEntriesStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteMultipleEntriesStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+declare class SqlDeleteMultipleEntriesImpl implements DeleteMultipleEntriesStorageOperation.Interface {
+    private readonly entryTableManager;
+    private readonly knex;
+    constructor(knexClient: KnexClient.Interface, entryTableManager: EntryTableManager.Interface);
+    private query;
+    execute(model: CmsModel, params: CmsEntryStorageOperationsDeleteEntriesParams): Promise<void>;
+}
+export declare const SqlDeleteMultipleEntries: typeof SqlDeleteMultipleEntriesImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteMultipleEntriesStorageOperation.js").IDeleteMultipleEntriesStorageOperation>;
+};
+export {};

package/operations/entry/SqlDeleteMultipleEntries.js

@@ -0,0 +1,29 @@
+import { DeleteMultipleEntriesStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteMultipleEntriesStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+import { parseIdentifier } from "@webiny/utils";
+import { createEntryQuery } from "./queryHelpers.js";
+class SqlDeleteMultipleEntriesImpl {
+    constructor(knexClient, entryTableManager){
+        this.entryTableManager = entryTableManager;
+        this.knex = knexClient.client;
+    }
+    query() {
+        return createEntryQuery(this.knex, this.entryTableManager.getTableName());
+    }
+    async execute(model, params) {
+        await this.entryTableManager.ensureTable();
+        const entryIds = params.entries.map((id)=>parseIdentifier(id).id);
+        await this.query().where("tenant", model.tenant).whereIn("entryId", entryIds).delete();
+    }
+}
+const SqlDeleteMultipleEntries = DeleteMultipleEntriesStorageOperation.createImplementation({
+    implementation: SqlDeleteMultipleEntriesImpl,
+    dependencies: [
+        KnexClient,
+        EntryTableManager
+    ]
+});
+export { SqlDeleteMultipleEntries };
+
+//# sourceMappingURL=SqlDeleteMultipleEntries.js.map

package/operations/entry/SqlDeleteMultipleEntries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations/entry/SqlDeleteMultipleEntries.js","sources":["../../../src/operations/entry/SqlDeleteMultipleEntries.ts"],"sourcesContent":["import type { Knex } from \"knex\";\nimport type {\n    CmsEntryStorageOperationsDeleteEntriesParams,\n    CmsModel\n} from \"@webiny/api-headless-cms/types/index.js\";\nimport { DeleteMultipleEntriesStorageOperation } from \"@webiny/api-headless-cms/features/shared/storageOperations/entry/DeleteMultipleEntriesStorageOperation.js\";\nimport { KnexClient } from \"@webiny/api-core-sql\";\nimport { EntryTableManager } from \"~/features/entryTableManager/abstractions.js\";\nimport { parseIdentifier } from \"@webiny/utils\";\nimport type { IEntryRow } from \"./types.js\";\nimport { createEntryQuery } from \"./queryHelpers.js\";\n\nclass SqlDeleteMultipleEntriesImpl implements DeleteMultipleEntriesStorageOperation.Interface {\n    private readonly knex: Knex;\n\n    public constructor(\n        knexClient: KnexClient.Interface,\n        private readonly entryTableManager: EntryTableManager.Interface\n    ) {\n        this.knex = knexClient.client;\n    }\n\n    private query(): Knex.QueryBuilder<IEntryRow> {\n        return createEntryQuery(this.knex, this.entryTableManager.getTableName());\n    }\n\n    async execute(model: CmsModel, params: CmsEntryStorageOperationsDeleteEntriesParams) {\n        await this.entryTableManager.ensureTable();\n\n        const entryIds = params.entries.map(id => parseIdentifier(id).id);\n\n        await this.query().where(\"tenant\", model.tenant).whereIn(\"entryId\", entryIds).delete();\n    }\n}\n\nexport const SqlDeleteMultipleEntries = DeleteMultipleEntriesStorageOperation.createImplementation({\n    implementation: SqlDeleteMultipleEntriesImpl,\n    dependencies: [KnexClient, EntryTableManager]\n});\n"],"names":["SqlDeleteMultipleEntriesImpl","knexClient","entryTableManager","createEntryQuery","model","params","entryIds","id","parseIdentifier","SqlDeleteMultipleEntries","DeleteMultipleEntriesStorageOperation","KnexClient","EntryTableManager"],"mappings":";;;;;AAYA,MAAMA;IAGF,YACIC,UAAgC,EACfC,iBAA8C,CACjE;aADmBA,iBAAiB,GAAjBA;QAEjB,IAAI,CAAC,IAAI,GAAGD,WAAW,MAAM;IACjC;IAEQ,QAAsC;QAC1C,OAAOE,iBAAiB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,iBAAiB,CAAC,YAAY;IAC1E;IAEA,MAAM,QAAQC,KAAe,EAAEC,MAAoD,EAAE;QACjF,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW;QAExC,MAAMC,WAAWD,OAAO,OAAO,CAAC,GAAG,CAACE,CAAAA,KAAMC,gBAAgBD,IAAI,EAAE;QAEhE,MAAM,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,UAAUH,MAAM,MAAM,EAAE,OAAO,CAAC,WAAWE,UAAU,MAAM;IACxF;AACJ;AAEO,MAAMG,2BAA2BC,sCAAsC,oBAAoB,CAAC;IAC/F,gBAAgBV;IAChB,cAAc;QAACW;QAAYC;KAAkB;AACjD"}

package/operations/entry/SqlGetEntriesByIds.d.ts

@@ -0,0 +1,15 @@
+import type { CmsEntry, CmsEntryStorageOperationsGetByIdsParams, CmsEntryValues, CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { GetEntriesByIdsStorageOperation } from "@webiny/api-headless-cms/features/shared/storageOperations/entry/GetEntriesByIdsStorageOperation.js";
+import { KnexClient } from "@webiny/api-core-sql";
+import { EntryTableManager } from "../../features/entryTableManager/abstractions.js";
+declare class SqlGetEntriesByIdsImpl implements GetEntriesByIdsStorageOperation.Interface {
+    private readonly entryTableManager;
+    private readonly knex;
+    constructor(knexClient: KnexClient.Interface, entryTableManager: EntryTableManager.Interface);
+    private query;
+    execute<T extends CmsEntryValues = CmsEntryValues>(model: CmsModel, params: CmsEntryStorageOperationsGetByIdsParams): Promise<CmsEntry<T>[]>;
+}
+export declare const SqlGetEntriesByIds: typeof SqlGetEntriesByIdsImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/shared/storageOperations/entry/GetEntriesByIdsStorageOperation.js").IGetEntriesByIdsStorageOperation>;
+};
+export {};