@wix/wix-data-items-common 1.0.307 → 1.0.309

package/dist/esm/api/WixDataApi.js

@@ -6,7 +6,7 @@ import { WixDataQueryImpl } from './impl/WixDataQueryImpl';
 import { WixDataResultImpl } from './impl/WixDataResultImpl';
 import { WixDataAggregateImpl } from './impl/WixDataAggregateImpl';
 import { ApiClient } from './ApiClient';
-import { WixDataBulkPatchImpl, WixDataPatchByFilterImpl, WixDataPatchImpl, } from './impl/WixDataPatchImpl';
+import { WixDataBulkPatchImpl, WixDataPatchImpl } from './impl/WixDataPatchImpl';
 import { WixDataSearchImpl } from './impl/WixDataSearchImpl';
 function createFilter(filter) {
     if (filter == null) {
@@ -68,111 +68,6 @@ export class WixDataApi {
                 });
             });
         });
-        // --- single-item methods ---
-        this.get = withArgs(async (args, collectionName, itemId, options) => {
-            await apiValidator()
-                .arity('get', args, 2, 3)
-                .collectionName(collectionName)
-                .itemId(itemId)
-                .options(options)
-                .validateAndReject();
-            return this.trace('get', { collectionName, itemId })(async (env) => {
-                const { dataItem } = await this.client
-                    .getDataItem({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    dataItemId: itemId,
-                    ...toReadOptions(options),
-                    fields: options?.fields,
-                    includeReferences: options?.includeReferences,
-                    ...(options?.includeFieldGroups?.length
-                        ? { includeFieldGroups: options.includeFieldGroups }
-                        : {}),
-                })
-                    .catch(recover(ItemDoesNotExistCode, {}));
-                return dataItem ? toDataItem(dataItem) : null;
-            });
-        });
-        this.insert = withArgs(async (args, collectionName, item, options) => {
-            await apiValidator()
-                .arity('insert', args, 2, 3)
-                .collectionName(collectionName)
-                .item(item, collectionName, false)
-                .options(options)
-                .validateAndReject();
-            warnAboutBrokenFields(item);
-            return this.trace('insert', { collectionName })(async (env) => {
-                const { dataItem } = await this.client.insertDataItem({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    dataItem: {
-                        id: item._id,
-                        data: item,
-                    },
-                    ...toInsertOptions(options),
-                });
-                return toDataItem(dataItem);
-            });
-        });
-        this.save = withArgs(async (args, collectionName, item, options) => {
-            await apiValidator()
-                .arity('save', args, 2, 3)
-                .collectionName(collectionName)
-                .item(item, collectionName, false)
-                .options(options)
-                .validateAndReject();
-            return this.trace('save', { collectionName })(async (env) => {
-                const { dataItem } = await this.client.saveDataItem({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    dataItem: {
-                        id: item._id,
-                        data: item,
-                    },
-                    ...toSaveOptions(options),
-                });
-                return toDataItem(dataItem);
-            });
-        });
-        this.update = withArgs(async (args, collectionName, item, options) => {
-            await apiValidator()
-                .arity('update', args, 2, 3)
-                .collectionName(collectionName)
-                .item(item, collectionName, false)
-                .options(options)
-                .validateAndReject();
-            return this.trace('update', { collectionName })(async (env) => {
-                const { dataItem } = await this.client.updateDataItem({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    dataItem: {
-                        id: item._id,
-                        data: item,
-                    },
-                    ...toUpdateOptions(options),
-                });
-                return toDataItem(dataItem);
-            });
-        });
-        this.remove = withArgs(async (args, collectionName, itemId, options) => {
-            await apiValidator()
-                .arity('remove', args, 2, 3)
-                .collectionName(collectionName)
-                .itemId(itemId)
-                .options(options)
-                .validateAndReject();
-            return this.trace('remove', { collectionName, itemId })(async (env) => {
-                const { dataItem } = await this.client
-                    .removeDataItem({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    dataItemId: itemId,
-                    ...toRemoveOptions(options),
-                })
-                    .catch(recover(ItemDoesNotExistCode, {}));
-                return dataItem ? toDataItem(dataItem) : null;
-            });
-        });
         this.toFieldModificationApi = (fieldModification) => {
             switch (fieldModification.action) {
                 case 'SET_FIELD':
@@ -214,26 +109,25 @@ export class WixDataApi {
                     };
             }
         };
-        this.asyncPatchByFilter = (collectionName, filter) => {
+        this.asyncPatchByFilter = withArgs(async (args, collectionName, filter, fieldModifications, options) => {
+            await apiValidator()
+                .arity('asyncPatchByFilter', args, 3, 4)
+                .collectionName(collectionName)
+                .options(options)
+                .validateAndReject();
             const apiFilter = createExplicitFilter(filter);
-            return new WixDataPatchByFilterImpl({
-                collectionName,
-                filter: apiFilter,
-                onRun: async (_args, patchParams, options) => {
-                    const fieldModifications = patchParams.fieldModifications.map(this.toFieldModificationApi);
-                    return this.trace('asyncPatchByFilter', { collectionName })(async (env) => {
-                        const { jobId } = await this.client.asyncPatchDataItemsByFilter({
-                            ...env,
-                            dataCollectionId: patchParams.collectionName,
-                            filter: patchParams.filter,
-                            fieldModifications,
-                            ...toAsyncByFilterOptions(options),
-                        });
-                        return { jobId: jobId };
-                    });
-                },
+            const apiFieldModifications = fieldModifications.map(this.toFieldModificationApi);
+            return this.trace('asyncPatchByFilter', { collectionName })(async (env) => {
+                const { jobId } = await this.client.asyncPatchDataItemsByFilter({
+                    ...env,
+                    dataCollectionId: collectionName,
+                    filter: apiFilter,
+                    fieldModifications: apiFieldModifications,
+                    ...toAsyncPatchByFilterOptions(options),
+                });
+                return { jobId: jobId };
             });
-        };
+        });
         this.asyncRemoveByFilter = withArgs(async (args, collectionName, filter, options) => {
             await apiValidator()
                 .arity('asyncRemoveByFilter', args, 2, 3)
@@ -323,37 +217,6 @@ export class WixDataApi {
                 return this.client.aggregatePipelineDataItems(request);
             });
         });
-        this.distinct = withArgs(async (args, collectionName, fieldName, options) => {
-            await apiValidator()
-                .arity('distinct', args, 2, 3)
-                .collectionName(collectionName)
-                .fieldName(fieldName)
-                .options(options)
-                .validateAndReject();
-            const limit = options?.paging?.limit ?? options?.cursorPaging?.limit;
-            const offset = options?.paging?.offset ?? 0;
-            const cursor = options?.cursorPaging?.cursor;
-            return this.trace('distinct', { collectionName, field: fieldName })(async (env) => {
-                const { distinctValues, pagingMetadata } = await this.client.queryDistinctValues({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    ...toReadOptions(options),
-                    ...toPaging(limit, cursor ?? offset),
-                    ...(cursor === undefined
-                        ? {
-                            fieldName,
-                            filter: options?.filter,
-                            order: options?.order,
-                            returnTotalCount: options?.returnTotalCount,
-                        }
-                        : {}),
-                });
-                return {
-                    values: distinctValues,
-                    pagingMetadata: pagingMetadata,
-                };
-            });
-        });
         /** @internal */
         this.count = withArgs(async (args, collectionName, options) => {
             await apiValidator()
@@ -391,45 +254,6 @@ export class WixDataApi {
                 return toBulkResult(itemIds, results, ['WDE0073']);
             });
         });
-        this.bulkInsert = withArgs(async (args, collectionName, items, options) => {
-            await apiValidator()
-                .arity('bulkInsert', args, 2, 3)
-                .items(items, collectionName)
-                .bulkInsertOptions(options)
-                .collectionName(collectionName)
-                .validateAndReject();
-            return this.trace('bulkInsert', { collectionName, options })(async (appId) => this.runBulkSave(appId, collectionName, items, options, options?.overrideExisting ?? false));
-        });
-        this.bulkSave = withArgs(async (args, collectionName, items, options) => {
-            await apiValidator()
-                .arity('bulkSave', args, 2, 3)
-                .bulkInsertOptions(options)
-                .collectionName(collectionName)
-                .items(items, collectionName)
-                .validateAndReject();
-            return this.trace('bulkSave', { collectionName })(async (env) => this.runBulkSave(env, collectionName, items, options));
-        });
-        this.bulkUpdate = withArgs(async (args, collectionName, items, options) => {
-            await apiValidator()
-                .arity('bulkUpdate', args, 2, 3)
-                .bulkUpdateOptions(options)
-                .collectionName(collectionName)
-                .items(items, collectionName)
-                .validateAndReject();
-            return this.trace('bulkUpdate', { collectionName })(async (env) => {
-                const { results } = await this.client.bulkUpdateDataItems({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    dataItems: items.map((data) => ({
-                        id: data._id,
-                        data,
-                    })),
-                    ...toBulkUpdateOptions(options),
-                });
-                // Non-existing items are skipped and not reported as errors.
-                return toBulkResult(items, results, ['WDE0073']);
-            });
-        });
         // --- references ---
         this.fetchReferenced = withArgs(async (args, collectionName, cursor, limit, options) => {
             await apiValidator()
@@ -497,39 +321,6 @@ export class WixDataApi {
                 skipNumber: options?.skip ?? 0,
             });
         });
-        this.queryReferencedItems = withArgs(async (args, collectionName, referringItem, referringItemFieldName, options) => {
-            await apiValidator()
-                .arity('queryReferencedItems', args, 3, 4)
-                .collectionName(collectionName)
-                .referenceParameters(asArray(referringItem))
-                .isNonEmptyString(referringItemFieldName, 'referringItemFieldName')
-                .options(options)
-                .validateAndReject();
-            const referringItemIds = asArray(referringItem).map(itemId);
-            return this.trace('queryReferencedItems', {
-                collectionName,
-                referringItemIds,
-                options,
-                referringItemFieldName,
-            })(async (env) => {
-                const { results, pagingMetadata } = await this.client.queryReferencedDataItems({
-                    ...env,
-                    ...toReadOptions(options),
-                    dataCollectionId: collectionName,
-                    referringItemIds,
-                    referringItemFieldName,
-                    order: options?.order,
-                    paging: options?.paging,
-                    cursorPaging: options?.cursorPaging,
-                    fields: options?.fields,
-                    returnTotalCount: options?.returnTotalCount,
-                });
-                return {
-                    results: toReferencedResults(results ?? []),
-                    pagingMetadata: pagingMetadata,
-                };
-            });
-        });
         this.insertReference = withArgs(async (args, collectionName, refsOrAttr, leftOrOpts, right, options) => {
             let refs;
             let opts;
@@ -644,6 +435,117 @@ export class WixDataApi {
     get filter() {
         return filterBuilder();
     }
+    // --- single-item methods ---
+    async get(collectionName, itemId, options) {
+        await apiValidator()
+            .arity('get', arguments, 2, 3)
+            .collectionName(collectionName)
+            .itemId(itemId)
+            .options(options)
+            .validateAndReject();
+        return this.trace('get', { collectionName, itemId })(async (env) => {
+            const { dataItem } = await this.client
+                .getDataItem({
+                ...env,
+                dataCollectionId: collectionName,
+                dataItemId: itemId,
+                ...toReadOptions(options),
+                fields: options?.fields,
+                includeReferences: options?.includeReferences,
+                ...(options?.includeFieldGroups?.length
+                    ? { includeFieldGroups: options.includeFieldGroups }
+                    : {}),
+            })
+                .catch(recover(ItemDoesNotExistCode, {}));
+            return dataItem
+                ? toDataItem(dataItem)
+                : null;
+        });
+    }
+    async insert(collectionName, item, options) {
+        const itemAsWixData = item;
+        await apiValidator()
+            .arity('insert', arguments, 2, 3)
+            .collectionName(collectionName)
+            .item(itemAsWixData, collectionName, false)
+            .options(options)
+            .validateAndReject();
+        warnAboutBrokenFields(itemAsWixData);
+        return this.trace('insert', { collectionName })(async (env) => {
+            const { dataItem } = await this.client.insertDataItem({
+                ...env,
+                dataCollectionId: collectionName,
+                dataItem: {
+                    id: itemAsWixData._id,
+                    data: itemAsWixData,
+                },
+                ...toInsertOptions(options),
+            });
+            return toDataItem(dataItem);
+        });
+    }
+    async save(collectionName, item, options) {
+        const itemAsWixData = item;
+        await apiValidator()
+            .arity('save', arguments, 2, 3)
+            .collectionName(collectionName)
+            .item(itemAsWixData, collectionName, false)
+            .options(options)
+            .validateAndReject();
+        return this.trace('save', { collectionName })(async (env) => {
+            const { dataItem } = await this.client.saveDataItem({
+                ...env,
+                dataCollectionId: collectionName,
+                dataItem: {
+                    id: itemAsWixData._id,
+                    data: itemAsWixData,
+                },
+                ...toSaveOptions(options),
+            });
+            return toDataItem(dataItem);
+        });
+    }
+    async update(collectionName, item, options) {
+        await apiValidator()
+            .arity('update', arguments, 2, 3)
+            .collectionName(collectionName)
+            .item(item, collectionName, false)
+            .options(options)
+            .validateAndReject();
+        return this.trace('update', { collectionName })(async (env) => {
+            const { dataItem } = await this.client.updateDataItem({
+                ...env,
+                dataCollectionId: collectionName,
+                dataItem: {
+                    id: item._id,
+                    data: item,
+                },
+                ...toUpdateOptions(options),
+            });
+            return toDataItem(dataItem);
+        });
+    }
+    async remove(collectionName, itemId, options) {
+        await apiValidator()
+            .arity('remove', arguments, 2, 3)
+            .collectionName(collectionName)
+            .itemId(itemId)
+            .options(options)
+            .validateAndReject();
+        return this.trace('remove', { collectionName, itemId })(async (env) => {
+            const { dataItem } = await this.client
+                .removeDataItem({
+                ...env,
+                dataCollectionId: collectionName,
+                dataItemId: itemId,
+                ...toRemoveOptions(options),
+            })
+                .catch(recover(ItemDoesNotExistCode, {}));
+            return dataItem
+                ? toDataItem(dataItem)
+                : null;
+        });
+    }
     patch(collectionName, itemId, fieldModifications, options) {
         if (arguments.length >= 3) {
             return this.executeDirectPatch(collectionName, itemId, fieldModifications, options);
@@ -680,7 +582,9 @@ export class WixDataApi {
                 },
                 ...toPatchOptions(options),
             });
-            return result.dataItem ? toDataItem(result.dataItem) : null;
+            return result.dataItem
+                ? toDataItem(result.dataItem)
+                : null;
         });
     }
     bulkPatch(collectionName, itemIds, fieldModifications, options) {
@@ -1018,6 +922,37 @@ export class WixDataApi {
             pagingMetadata: pagingMetadata,
         };
     }
+    async distinct(collectionName, fieldName, options) {
+        await apiValidator()
+            .arity('distinct', arguments, 2, 3)
+            .collectionName(collectionName)
+            .fieldName(fieldName)
+            .options(options)
+            .validateAndReject();
+        const limit = options?.paging?.limit ?? options?.cursorPaging?.limit;
+        const offset = options?.paging?.offset ?? 0;
+        const cursor = options?.cursorPaging?.cursor;
+        return this.trace('distinct', { collectionName, field: fieldName })(async (env) => {
+            const { distinctValues, pagingMetadata } = await this.client.queryDistinctValues({
+                ...env,
+                dataCollectionId: collectionName,
+                ...toReadOptions(options),
+                ...toPaging(limit, cursor ?? offset),
+                ...(cursor === undefined
+                    ? {
+                        fieldName,
+                        filter: options?.filter,
+                        order: options?.order,
+                        returnTotalCount: options?.returnTotalCount,
+                    }
+                    : {}),
+            });
+            return {
+                values: distinctValues,
+                pagingMetadata: pagingMetadata,
+            };
+        });
+    }
     async runBulkSave(env, collectionName, items, options, overrideExisting = true) {
         const request = {
             ...env,
@@ -1035,6 +970,80 @@ export class WixDataApi {
         const ignoreCodes = overrideExisting ? [] : ['WDE0074'];
         return toBulkResult(items, results, ignoreCodes);
     }
+    async bulkInsert(collectionName, items, options) {
+        const itemsAsWixData = items;
+        await apiValidator()
+            .arity('bulkInsert', arguments, 2, 3)
+            .items(itemsAsWixData, collectionName)
+            .bulkInsertOptions(options)
+            .collectionName(collectionName)
+            .validateAndReject();
+        return this.trace('bulkInsert', { collectionName, options })(async (appId) => this.runBulkSave(appId, collectionName, itemsAsWixData, options, options?.overrideExisting ?? false));
+    }
+    async bulkSave(collectionName, items, options) {
+        const itemsAsWixData = items;
+        await apiValidator()
+            .arity('bulkSave', arguments, 2, 3)
+            .bulkInsertOptions(options)
+            .collectionName(collectionName)
+            .items(itemsAsWixData, collectionName)
+            .validateAndReject();
+        return this.trace('bulkSave', { collectionName })(async (env) => this.runBulkSave(env, collectionName, itemsAsWixData, options));
+    }
+    async bulkUpdate(collectionName, items, options) {
+        await apiValidator()
+            .arity('bulkUpdate', arguments, 2, 3)
+            .bulkUpdateOptions(options)
+            .collectionName(collectionName)
+            .items(items, collectionName)
+            .validateAndReject();
+        return this.trace('bulkUpdate', { collectionName })(async (env) => {
+            const { results } = await this.client.bulkUpdateDataItems({
+                ...env,
+                dataCollectionId: collectionName,
+                dataItems: items.map((data) => ({
+                    id: data._id,
+                    data,
+                })),
+                ...toBulkUpdateOptions(options),
+            });
+            // Non-existing items are skipped and not reported as errors.
+            return toBulkResult(items, results, ['WDE0073']);
+        });
+    }
+    async queryReferencedItems(collectionName, referringItem, referringItemFieldName, options) {
+        await apiValidator()
+            .arity('queryReferencedItems', arguments, 3, 4)
+            .collectionName(collectionName)
+            .referenceParameters(asArray(referringItem))
+            .isNonEmptyString(referringItemFieldName, 'referringItemFieldName')
+            .options(options)
+            .validateAndReject();
+        const referringItemIds = asArray(referringItem).map(itemId);
+        return this.trace('queryReferencedItems', {
+            collectionName,
+            referringItemIds,
+            options,
+            referringItemFieldName,
+        })(async (env) => {
+            const { results, pagingMetadata } = await this.client.queryReferencedDataItems({
+                ...env,
+                ...toReadOptions(options),
+                dataCollectionId: collectionName,
+                referringItemIds,
+                referringItemFieldName,
+                order: options?.order,
+                paging: options?.paging,
+                cursorPaging: options?.cursorPaging,
+                fields: options?.fields,
+                returnTotalCount: options?.returnTotalCount,
+            });
+            return {
+                results: toReferencedResults(results ?? []),
+                pagingMetadata: pagingMetadata,
+            };
+        });
+    }
     trace(action, opts) {
         return async (fn) => {
             const gridAppId = await get(this.gridAppId);
@@ -1068,10 +1077,10 @@ function toBulkPatchOptions(options) {
         ...conditionOptions(options?.condition),
     };
 }
-function toAsyncByFilterOptions(options) {
+function toAsyncRemoveByFilterOptions(options) {
     return toAsyncOptions(options);
 }
-function toAsyncRemoveByFilterOptions(options) {
+function toAsyncPatchByFilterOptions(options) {
     return toAsyncOptions(options);
 }
 function toAsyncOptions(options) {