@wix/wix-data-items-common 1.0.308 → 1.0.310

package/dist/esm/api/WixDataApi.js

@@ -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':
@@ -322,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()
@@ -390,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()
@@ -496,152 +321,124 @@ 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;
-            let argc;
-            if (typeof refsOrAttr === 'string') {
-                const rights = asArray(right);
-                refs = rights.map((r) => ({
-                    relationshipName: refsOrAttr,
-                    left: leftOrOpts,
-                    right: r,
-                }));
-                opts = options;
-                argc = [4, 5];
-            }
-            else {
-                refs = refsOrAttr;
-                opts = leftOrOpts;
-                argc = [2, 3];
-            }
-            await apiValidator()
-                .arity('insertReference', args, ...argc)
-                .collectionName(collectionName)
-                .references(refs)
-                .options(opts)
-                .validateAndReject();
-            await this.trace('insertReference', { collectionName })(async (env) => this.client.bulkInsertDataItemReferences({
+        this.client = new ApiClient(clientFactory, allowGet);
+    }
+    get wixData() {
+        return this;
+    }
+    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,
-                dataItemReferences: refs.map((r) => ({
-                    referringItemFieldName: r.relationshipName,
-                    referringItemId: itemId(r.left),
-                    referencedItemId: itemId(r.right),
-                })),
-                ...toOptions(opts),
-            }));
+                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.replaceReferences = withArgs(async (args, collectionName, relationshipAttribute, left, right, options) => {
-            const rights = asArray(right);
-            await apiValidator()
-                .arity('replaceReferences', args, 4, 5)
-                .collectionName(collectionName)
-                .isNonEmptyString(relationshipAttribute, 'relationshipAttribute')
-                .referenceParameter(left)
-                .referenceParameters(rights)
-                .options(options)
-                .validateAndReject();
-            await this.trace('replaceReferences', {
-                collectionName,
-                relationshipAttribute,
-            })(async (env) => this.client.replaceDataItemReferences({
+    }
+    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,
-                referringItemFieldName: relationshipAttribute,
-                referringItemId: itemId(left),
-                newReferencedItemIds: rights.map(itemId),
-                ...toOptions(options),
-            }));
+                dataItem: {
+                    id: itemAsWixData._id,
+                    data: itemAsWixData,
+                },
+                ...toInsertOptions(options),
+            });
+            return toDataItem(dataItem);
         });
-        this.removeReference = withArgs(async (args, collectionName, relationshipAttribute, left, right, options) => {
-            const rights = asArray(right);
-            await apiValidator()
-                .arity('removeReference', args, 4, 5)
-                .collectionName(collectionName)
-                .referenceParameter(left)
-                .referenceRemoveParameters(rights)
-                .isNonEmptyString(relationshipAttribute, 'relationshipAttribute')
-                .options(options)
-                .validateAndReject();
-            await this.trace('removeReference', {
-                collectionName,
-                relationshipAttribute,
-            })(async (env) => this.client.bulkRemoveDataItemReferences({
+    }
+    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,
-                dataItemReferences: rights.map((r) => ({
-                    referringItemFieldName: relationshipAttribute,
-                    referringItemId: itemId(left),
-                    referencedItemId: itemId(r),
-                })),
-                ...toOptions(options),
-            }));
-        });
-        this.isReferenced = withArgs(async (args, collectionName, relationshipAttribute, left, right, options) => {
-            await apiValidator()
-                .arity('isReferenced', args, 4, 5)
-                .collectionName(collectionName)
-                .referenceParameter(left)
-                .referenceParameter(right)
-                .options(options)
-                .validateAndReject();
-            return this.trace('isReferenced', {
-                collectionName,
-                relationshipAttribute,
-            })(async (env) => {
-                const { isReferenced } = await this.client.isReferencedDataItem({
-                    ...env,
-                    dataCollectionId: collectionName,
-                    referringItemFieldName: relationshipAttribute,
-                    referringItemId: itemId(left),
-                    referencedItemId: itemId(right),
-                    ...toReadOptions(options),
-                    consistentRead: options?.consistentRead,
-                });
-                return isReferenced;
+                dataItem: {
+                    id: itemAsWixData._id,
+                    data: itemAsWixData,
+                },
+                ...toSaveOptions(options),
             });
+            return toDataItem(dataItem);
         });
-        this.client = new ApiClient(clientFactory, allowGet);
     }
-    get wixData() {
-        return this;
+    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);
+        });
     }
-    get filter() {
-        return filterBuilder();
+    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) {
@@ -679,7 +476,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) {
@@ -1017,6 +816,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,
@@ -1034,6 +864,186 @@ 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,
+            };
+        });
+    }
+    async insertReference(collectionName, refsOrAttr, leftOrOpts, right, options) {
+        let refs;
+        let opts;
+        let argc;
+        if (typeof refsOrAttr === 'string') {
+            const rights = asArray(right);
+            refs = rights.map((r) => ({
+                relationshipName: refsOrAttr,
+                left: leftOrOpts,
+                right: r,
+            }));
+            opts = options;
+            argc = [4, 5];
+        }
+        else {
+            refs = refsOrAttr;
+            opts = leftOrOpts;
+            argc = [2, 3];
+        }
+        await apiValidator()
+            .arity('insertReference', arguments, ...argc)
+            .collectionName(collectionName)
+            .references(refs)
+            .options(opts)
+            .validateAndReject();
+        await this.trace('insertReference', { collectionName })(async (env) => this.client.bulkInsertDataItemReferences({
+            ...env,
+            dataCollectionId: collectionName,
+            dataItemReferences: refs.map((r) => ({
+                referringItemFieldName: r.relationshipName,
+                referringItemId: itemId(r.left),
+                referencedItemId: itemId(r.right),
+            })),
+            ...toOptions(opts),
+        }));
+    }
+    async replaceReferences(collectionName, relationshipAttribute, left, right, options) {
+        const rights = asArray(right);
+        await apiValidator()
+            .arity('replaceReferences', arguments, 4, 5)
+            .collectionName(collectionName)
+            .isNonEmptyString(relationshipAttribute, 'relationshipAttribute')
+            .referenceParameter(left)
+            .referenceParameters(rights)
+            .options(options)
+            .validateAndReject();
+        await this.trace('replaceReferences', {
+            collectionName,
+            relationshipAttribute,
+        })(async (env) => this.client.replaceDataItemReferences({
+            ...env,
+            dataCollectionId: collectionName,
+            referringItemFieldName: relationshipAttribute,
+            referringItemId: itemId(left),
+            newReferencedItemIds: rights.map(itemId),
+            ...toOptions(options),
+        }));
+    }
+    async removeReference(collectionName, relationshipAttribute, left, right, options) {
+        const rights = asArray(right);
+        await apiValidator()
+            .arity('removeReference', arguments, 4, 5)
+            .collectionName(collectionName)
+            .referenceParameter(left)
+            .referenceRemoveParameters(rights)
+            .isNonEmptyString(relationshipAttribute, 'relationshipAttribute')
+            .options(options)
+            .validateAndReject();
+        await this.trace('removeReference', {
+            collectionName,
+            relationshipAttribute,
+        })(async (env) => this.client.bulkRemoveDataItemReferences({
+            ...env,
+            dataCollectionId: collectionName,
+            dataItemReferences: rights.map((r) => ({
+                referringItemFieldName: relationshipAttribute,
+                referringItemId: itemId(left),
+                referencedItemId: itemId(r),
+            })),
+            ...toOptions(options),
+        }));
+    }
+    async isReferenced(collectionName, relationshipAttribute, left, right, options) {
+        await apiValidator()
+            .arity('isReferenced', arguments, 4, 5)
+            .collectionName(collectionName)
+            .referenceParameter(left)
+            .referenceParameter(right)
+            .options(options)
+            .validateAndReject();
+        return this.trace('isReferenced', {
+            collectionName,
+            relationshipAttribute,
+        })(async (env) => {
+            const { isReferenced } = await this.client.isReferencedDataItem({
+                ...env,
+                dataCollectionId: collectionName,
+                referringItemFieldName: relationshipAttribute,
+                referringItemId: itemId(left),
+                referencedItemId: itemId(right),
+                ...toReadOptions(options),
+                consistentRead: options?.consistentRead,
+            });
+            return isReferenced;
+        });
+    }
     trace(action, opts) {
         return async (fn) => {
             const gridAppId = await get(this.gridAppId);