@webiny/api-headless-cms-ddb 5.18.3 → 5.19.0-beta.3

package/dynamoDb/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => (import("@webiny/api-headless-cms").StorageTransformPlugin<any, any> | import("../types").CmsFieldFilterValueTransformPlugin | import("../types").CmsFieldFilterPathPlugin)[];
+declare const _default: () => (import("@webiny/api-headless-cms").StorageTransformPlugin<any, any> | import("../plugins/CmsEntryFieldFilterPathPlugin").CmsEntryFieldFilterPathPlugin | import("../types").CmsFieldFilterValueTransformPlugin)[];
 export default _default;

package/dynamoDb/index.js

@@ -13,12 +13,10 @@ var _longText = _interopRequireDefault(require("./storage/longText"));
 
 var _date = _interopRequireDefault(require("./storage/date"));
 
-var _plainObject = _interopRequireDefault(require("./path/plainObject"));
-
-var _ref = _interopRequireDefault(require("./path/ref"));
+var _plainObject = require("./path/plainObject");
 
 var _datetime = _interopRequireDefault(require("./transformValue/datetime"));
 
-var _default = () => [(0, _richText.default)(), (0, _longText.default)(), (0, _date.default)(), (0, _plainObject.default)(), (0, _ref.default)(), (0, _datetime.default)()];
+var _default = () => [(0, _richText.default)(), (0, _longText.default)(), (0, _date.default)(), (0, _plainObject.createPlainObjectPathPlugin)(), (0, _datetime.default)()];
 
 exports.default = _default;

package/dynamoDb/path/plainObject.d.ts

@@ -1,3 +1,2 @@
-import { CmsFieldFilterPathPlugin } from "../../types";
-declare const _default: () => CmsFieldFilterPathPlugin;
-export default _default;
+import { CmsEntryFieldFilterPathPlugin } from "../../plugins/CmsEntryFieldFilterPathPlugin";
+export declare const createPlainObjectPathPlugin: () => CmsEntryFieldFilterPathPlugin;

package/dynamoDb/path/plainObject.js

@@ -5,29 +5,33 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.createPlainObjectPathPlugin = void 0;
 
 var _error = _interopRequireDefault(require("@webiny/error"));
 
-var _default = () => ({
-  type: "cms-field-filter-path",
-  name: "cms-field-filter-path-plain-object",
-  fieldType: "plainObject",
-  createPath: ({
-    field
-  }) => {
-    const {
-      path
-    } = field.settings || {};
-
-    if (!path) {
-      throw new _error.default("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
-        field
-      });
-    }
-
-    return path;
+var _CmsEntryFieldFilterPathPlugin = require("../../plugins/CmsEntryFieldFilterPathPlugin");
+
+const createPath = ({
+  field
+}) => {
+  const {
+    path
+  } = field.settings || {};
+
+  if (!path) {
+    throw new _error.default("Missing path settings value.", "FIELD_SETTINGS_ERROR", {
+      field
+    });
   }
-});
 
-exports.default = _default;
+  return path;
+};
+
+const createPlainObjectPathPlugin = () => {
+  return new _CmsEntryFieldFilterPathPlugin.CmsEntryFieldFilterPathPlugin({
+    fieldType: "plainObject",
+    path: createPath
+  });
+};
+
+exports.createPlainObjectPathPlugin = createPlainObjectPathPlugin;

package/operations/entry/dataLoaders.js

@@ -37,7 +37,7 @@ const getAllEntryRevisions = params => {
     locale
   } = model;
   return new _dataloader.default(async ids => {
-    const results = [];
+    const results = {};
 
     for (const id of ids) {
       const queryAllParams = {
@@ -52,11 +52,12 @@ const getAllEntryRevisions = params => {
         }
       };
       const items = await (0, _query.queryAll)(queryAllParams);
-      const entries = (0, _cleanup.cleanupItems)(entity, items);
-      results.push(entries);
+      results[id] = (0, _cleanup.cleanupItems)(entity, items);
     }
 
-    return results;
+    return ids.map(id => {
+      return results[id] || [];
+    });
   });
 };
 

package/operations/entry/index.js

@@ -331,13 +331,6 @@ const createEntriesStorageOperations = params => {
     }
   };
 
-  const getAllRevisionsByIds = async (model, params) => {
-    return await dataLoaders.getAllEntryRevisions({
-      model,
-      ids: params.ids
-    });
-  };
-
   const getLatestRevisionByEntryId = async (model, params) => {
     const result = await dataLoaders.getLatestRevisionByEntryId({
       model,
@@ -408,7 +401,9 @@ const createEntriesStorageOperations = params => {
   const getPreviousRevision = async (model, params) => {
     const {
       tenant,
-      locale,
+      locale
+    } = model;
+    const {
       entryId,
       version
     } = params;
@@ -456,7 +451,7 @@ const createEntriesStorageOperations = params => {
       after,
       sort
     } = params;
-    const limit = initialLimit <= 0 || initialLimit >= 100 ? 100 : initialLimit;
+    const limit = initialLimit <= 0 || initialLimit >= 10000 ? 10000 : initialLimit;
     const type = originalWhere.published ? "P" : "L";
     const queryAllParams = {
       entity,
@@ -709,7 +704,7 @@ const createEntriesStorageOperations = params => {
       })));
     }
 
-    if (publishedStorageEntry) {
+    if (publishedStorageEntry && publishedStorageEntry.id !== entry.id) {
       items.push(entity.putBatch(_objectSpread(_objectSpread({}, publishedStorageEntry), {}, {
         PK: partitionKey,
         SK: (0, _keys.createRevisionSortKey)(publishedStorageEntry),
@@ -806,7 +801,6 @@ const createEntriesStorageOperations = params => {
     getByIds,
     getRevisionById,
     getPublishedRevisionByEntryId,
-    getAllRevisionsByIds,
     getLatestRevisionByEntryId,
     get,
     getRevisions,

package/operations/entry/systemFields.js

@@ -45,6 +45,11 @@ const systemFields = {
     settings: {
       path: "ownedBy.id"
     }
+  }),
+  version: createSystemField({
+    id: "version",
+    type: "number",
+    fieldId: "version"
   })
 };
 exports.systemFields = systemFields;

package/operations/entry/utils.d.ts

@@ -1,9 +1,10 @@
 import { CmsEntry, CmsEntryListWhere, CmsModel, CmsModelField } from "@webiny/api-headless-cms/types";
 import { PluginsContainer } from "@webiny/plugins";
+import { CreatePathCallable as CmsEntryFieldFieldCreatePathCallable } from "../../plugins/CmsEntryFieldFilterPathPlugin";
 interface ModelField {
     def: CmsModelField;
     valueTransformer: (value: any) => any;
-    valuePath: string;
+    createPath: CmsEntryFieldFieldCreatePathCallable;
     isSystemField?: boolean;
 }
 declare type ModelFieldRecords = Record<string, ModelField>;

package/operations/entry/utils.js

@@ -17,6 +17,8 @@ var _systemFields = require("./systemFields");
 
 var _ValueFilterPlugin = require("@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin");
 
+var _CmsEntryFieldFilterPathPlugin = require("../../plugins/CmsEntryFieldFilterPathPlugin");
+
 const VALUES_ATTRIBUTE = "values";
 
 const extractWhereParams = key => {
@@ -52,6 +54,63 @@ const transformValue = (value, transform) => {
   return transform(value);
 };
 
+const getFilterPlugin = params => {
+  const {
+    plugins,
+    operation
+  } = params;
+  const plugin = plugins[operation];
+
+  if (plugin) {
+    return plugin;
+  }
+
+  throw new _error.default(`There is no filter plugin for operation "${operation}".`, "FILTER_PLUGIN_ERROR", {
+    operation
+  });
+};
+
+const createValuePath = params => {
+  const {
+    field,
+    plugins,
+    index
+  } = params;
+  const {
+    fieldId
+  } = field;
+  const valuePathPlugin = plugins[field.type];
+  const basePath = _systemFields.systemFields[fieldId] ? "" : `${VALUES_ATTRIBUTE}.`;
+
+  if (!valuePathPlugin || valuePathPlugin.canUse(field) === false) {
+    return `${basePath}${field.fieldId}`;
+  }
+
+  const path = valuePathPlugin.createPath({
+    field,
+    index
+  });
+  return `${basePath}${path}`;
+};
+
+const isObjectFiltering = params => {
+  const {
+    value
+  } = params;
+
+  if (!value) {
+    return false;
+  } else if (Array.isArray(value) === true) {
+    return false;
+  } else if (value instanceof Date || !!value.toISOString) {
+    return false;
+  } else if (typeof value !== "object") {
+    return false;
+  }
+
+  return true;
+};
+
 const createFilters = params => {
   const {
     where,
@@ -70,10 +129,16 @@ const createFilters = params => {
   });
   const valuePathPlugins = getMappedPlugins({
     plugins,
-    type: "cms-field-filter-path",
+    type: _CmsEntryFieldFilterPathPlugin.CmsEntryFieldFilterPathPlugin.type,
     property: "fieldType"
   });
-  return Object.keys(where).map(key => {
+  const filters = [];
+
+  for (const key in where) {
+    if (where.hasOwnProperty(key) === false) {
+      continue;
+    }
+
     const {
       fieldId,
       operation,
@@ -88,33 +153,6 @@ const createFilters = params => {
     }
 
     const transformValuePlugin = transformValuePlugins[field.def.type];
-    const valuePathPlugin = valuePathPlugins[field.def.type];
-    let targetValuePath;
-    /**
-     * add the base path if field is not a system field
-     * pathPlugin should not know about that
-     */
-
-    const basePath = _systemFields.systemFields[fieldId] ? "" : `${VALUES_ATTRIBUTE}.`;
-
-    if (valuePathPlugin) {
-      targetValuePath = valuePathPlugin.createPath({
-        field: field.def
-      });
-    } else if (_systemFields.systemFields[fieldId]) {
-      targetValuePath = fieldId;
-    } else {
-      targetValuePath = field.def.fieldId;
-    }
-
-    const valuePath = `${basePath}${targetValuePath}`;
-    const filterPlugin = filterPlugins[operation];
-
-    if (!filterPlugin) {
-      throw new _error.default(`There is no filter plugin for operation "${operation}".`, "FILTER_PLUGIN_ERROR", {
-        operation
-      });
-    }
 
     const transformValueCallable = value => {
       if (!transformValuePlugin) {
@@ -127,20 +165,111 @@ const createFilters = params => {
       });
     };
 
-    return {
+    const objectFilteringParams = {
+      key,
+      value: where[key],
+      field: field.def
+    };
+
+    if (isObjectFiltering(objectFilteringParams)) {
+      const propertyFilters = Object.keys(where[key]);
+
+      if (propertyFilters.length === 0) {
+        continue;
+      }
+
+      for (const propertyFilter of propertyFilters) {
+        const {
+          fieldId: propertyId,
+          operation: propertyOperation,
+          negate: propertyNegate
+        } = extractWhereParams(propertyFilter);
+        const filterPlugin = getFilterPlugin({
+          plugins: filterPlugins,
+          operation: propertyOperation
+        });
+        const basePath = createValuePath({
+          field: field.def,
+          plugins: valuePathPlugins
+        });
+        const multiValuesPath = field.def.multipleValues ? "%s." : "";
+        filters.push({
+          fieldId,
+          path: `${basePath}.${multiValuesPath}${propertyId}`,
+          filterPlugin,
+          negate: propertyNegate,
+          compareValue: transformValue(where[key][propertyFilter], transformValueCallable),
+          transformValue: transformValueCallable
+        });
+      }
+
+      continue;
+    }
+
+    const filterPlugin = getFilterPlugin({
+      plugins: filterPlugins,
+      operation
+    });
+    filters.push({
       fieldId,
-      path: valuePath,
+      path: createValuePath({
+        field: field.def,
+        plugins: valuePathPlugins
+      }),
       filterPlugin,
       negate,
       compareValue: transformValue(where[key], transformValueCallable),
       transformValue: transformValueCallable
-    };
+    });
+  }
+
+  return filters;
+};
+/**
+ * In case filter field is not multiple values one, return exact path.
+ * If is multiple values field, use path without the last part
+ */
+
+
+const getFilterValuePath = filter => {
+  if (filter.path.includes(".%s.") === false) {
+    return filter.path;
+  }
+
+  const paths = filter.path.split(".%s.");
+  return paths.shift();
+};
+
+const getFilterValuePropertyPath = filter => {
+  if (filter.path.includes(".%s.") === false) {
+    return null;
+  }
+
+  const paths = filter.path.split(".%s.");
+  return paths.pop();
+};
+
+const execFilter = params => {
+  const {
+    value: plainValue,
+    filter
+  } = params;
+  const value = transformValue(plainValue, filter.transformValue);
+  const matched = filter.filterPlugin.matches({
+    value,
+    compareValue: filter.compareValue
   });
+
+  if (filter.negate) {
+    return matched === false;
+  }
+
+  return matched;
 };
 
 const filterItems = async params => {
   const {
-    items,
+    items: records,
     where,
     plugins,
     fields,
@@ -151,18 +280,55 @@ const filterItems = async params => {
     where,
     fields
   });
-  const results = [];
+  const promises = records.map(async record => {
+    /**
+     * We need to go through all the filters and apply them to the given record.
+     */
+    for (const filter of filters) {
+      /**
+       * In case is multiple values field, last part is removed from path.
+       * -> values.categories.id -> values.categories
+       */
+      const valuePath = getFilterValuePath(filter);
 
-  for (const key in items) {
-    if (items.hasOwnProperty(key) === false) {
-      continue;
-    }
+      const rawValue = _dotProp.default.get(record, valuePath);
 
-    const item = items[key];
-    let passed = true;
+      if (valuePath !== filter.path) {
+        /**
+         * Calculated is different than original because we need to search in the array of objects.
+         */
+        const propertyPath = getFilterValuePropertyPath(filter);
 
-    for (const filter of filters) {
-      const rawValue = _dotProp.default.get(item, filter.path);
+        if (!propertyPath) {
+          console.log(`Cannot determine the property path of "${filter.path}".`);
+          continue;
+        }
+
+        const plainValue = await fromStorage(fields[filter.fieldId].def, rawValue);
+        /**
+         * We cannot go through the value because it is not array. Log the error and continue.
+         */
+
+        if (Array.isArray(plainValue) === false) {
+          console.log(`Cannot go through the value on ${valuePath} because it is not an array, and we expect it to be.`);
+          continue;
+        }
+
+        record = _dotProp.default.set(record, valuePath, plainValue);
+        const values = plainValue.map(value => {
+          return value[propertyPath];
+        });
+        const result = execFilter({
+          value: values,
+          filter
+        });
+
+        if (!result) {
+          return null;
+        }
+
+        continue;
+      }
 
       const plainValue = await fromStorage(fields[filter.fieldId].def, rawValue);
       /**
@@ -170,46 +336,31 @@ const filterItems = async params => {
        */
 
       if (plainValue !== rawValue) {
-        items[key] = _dotProp.default.set(item, filter.path, plainValue);
+        record = _dotProp.default.set(record, filter.path, plainValue);
       }
 
-      const value = transformValue(plainValue, filter.transformValue);
-      const matched = filter.filterPlugin.matches({
-        value,
-        compareValue: filter.compareValue
+      const result = execFilter({
+        value: plainValue,
+        filter
       });
 
-      if ((filter.negate ? !matched : matched) === false) {
-        passed = false;
-        break;
+      if (result === false) {
+        return null;
       }
     }
 
-    if (!passed) {
-      continue;
-    }
+    return record;
+  });
+  /**
+   * We run filtering as promises so it is a bit faster than in for ... of loop.
+   */
 
-    results.push(item);
-  }
+  const results = await Promise.all(promises);
+  /**
+   * And filter out the null values which are returned when filter is not satisfied.
+   */
 
-  return results; // return items.filter(item => {
-  //     for (const filter of filters) {
-  //         const plainValue = await fromStorage(
-  //             fields[filter.fieldId].def,
-  //             dotProp.get(item, filter.path)
-  //         );
-  //
-  //         const value = transformValue(plainValue, filter.transformValue);
-  //         const matched = filter.filterPlugin.matches({
-  //             value,
-  //             compareValue: filter.compareValue
-  //         });
-  //         if ((filter.negate ? !matched : matched) === false) {
-  //             return false;
-  //         }
-  //     }
-  //     return true;
-  // });
+  return results.filter(Boolean);
 };
 
 exports.filterItems = filterItems;
@@ -233,7 +384,9 @@ const extractSort = (sortBy, fields) => {
     });
   }
 
-  const valuePath = modelField.valuePath;
+  const valuePath = modelField.createPath({
+    field: modelField.def
+  });
   return {
     fieldId,
     valuePath,
@@ -342,18 +495,21 @@ const buildModelFields = ({
   });
   const valuePathPlugins = getMappedPlugins({
     plugins,
-    type: "cms-field-filter-path",
+    type: _CmsEntryFieldFilterPathPlugin.CmsEntryFieldFilterPathPlugin.type,
     property: "fieldType"
   });
   const fields = Object.values(_systemFields.systemFields).reduce((collection, field) => {
     const transformValuePlugin = transformValuePlugins[field.type];
     const valuePathPlugin = valuePathPlugins[field.type];
-    let valuePath;
+
+    let createPath = params => {
+      return params.field.fieldId;
+    };
 
     if (valuePathPlugin) {
-      valuePath = valuePathPlugin.createPath({
-        field
-      });
+      createPath = params => {
+        return valuePathPlugin.createPath(params);
+      };
     }
 
     collection[field.fieldId] = {
@@ -368,7 +524,7 @@ const buildModelFields = ({
           value
         });
       },
-      valuePath: valuePath || field.fieldId,
+      createPath,
       isSystemField: true
     };
     return collection;
@@ -376,15 +532,17 @@ const buildModelFields = ({
   return model.fields.reduce((collection, field) => {
     const transformValuePlugin = transformValuePlugins[field.type];
     const valuePathPlugin = valuePathPlugins[field.type];
-    let valuePath;
+
+    let createPath = params => {
+      return `${VALUES_ATTRIBUTE}.${params.field.fieldId}`;
+    };
 
     if (valuePathPlugin) {
-      valuePath = valuePathPlugin.createPath({
-        field
-      });
+      createPath = params => {
+        return valuePathPlugin.createPath(params);
+      };
     }
 
-    const targetValuePath = `${VALUES_ATTRIBUTE}.${valuePath || field.fieldId}`;
     collection[field.fieldId] = {
       def: field,
       valueTransformer: value => {
@@ -397,7 +555,7 @@ const buildModelFields = ({
           value
         });
       },
-      valuePath: targetValuePath || field.fieldId
+      createPath
     };
     return collection;
   }, fields);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/api-headless-cms-ddb",
-	"version": "5.18.3",
+	"version": "5.19.0-beta.3",
 	"main": "index.js",
 	"keywords": [
 		"@webiny/api-headless-cms",
@@ -22,11 +22,11 @@
 	"license": "MIT",
 	"dependencies": {
 		"@babel/runtime": "7.16.3",
-		"@webiny/api-headless-cms": "5.18.3",
-		"@webiny/db-dynamodb": "5.18.3",
-		"@webiny/error": "5.18.3",
-		"@webiny/handler-db": "5.18.3",
-		"@webiny/utils": "5.18.3",
+		"@webiny/api-headless-cms": "5.19.0-beta.3",
+		"@webiny/db-dynamodb": "5.19.0-beta.3",
+		"@webiny/error": "5.19.0-beta.3",
+		"@webiny/handler-db": "5.19.0-beta.3",
+		"@webiny/utils": "5.19.0-beta.3",
 		"aws-sdk": "2.1032.0",
 		"dataloader": "2.0.0",
 		"dot-prop": "5.3.0",
@@ -40,9 +40,9 @@
 		"@babel/preset-env": "^7.5.5",
 		"@babel/preset-flow": "^7.0.0",
 		"@types/jsonpack": "^1.1.0",
-		"@webiny/cli": "^5.18.3",
-		"@webiny/plugins": "^5.18.3",
-		"@webiny/project-utils": "^5.18.3",
+		"@webiny/cli": "^5.19.0-beta.3",
+		"@webiny/plugins": "^5.19.0-beta.3",
+		"@webiny/project-utils": "^5.19.0-beta.3",
 		"jest": "^26.6.3",
 		"jest-dynalite": "^3.2.0",
 		"jest-environment-node": "^26.6.2",
@@ -57,5 +57,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "3ccdb07d10c57086a63eb42ba7484e17bc388297"
+	"gitHead": "a1cca819f83172183b907de16fd5746d07d13ad0"
 }

package/plugins/CmsEntryFieldFilterPathPlugin.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "@webiny/plugins/Plugin";
+import { CmsModelField } from "@webiny/api-headless-cms/types";
+export interface CreatePathCallableParams {
+    field: CmsModelField;
+    index?: number;
+}
+export interface CreatePathCallable {
+    (params: CreatePathCallableParams): string;
+}
+export interface Params {
+    fieldType: string;
+    fieldId?: string[];
+    path: string | CreatePathCallable;
+}
+export declare class CmsEntryFieldFilterPathPlugin extends Plugin {
+    static readonly type: string;
+    private readonly config;
+    get fieldType(): string;
+    constructor(config: Params);
+    canUse(field: CmsModelField): boolean;
+    createPath(params: CreatePathCallableParams): string;
+}

package/plugins/CmsEntryFieldFilterPathPlugin.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsEntryFieldFilterPathPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _Plugin = require("@webiny/plugins/Plugin");
+
+class CmsEntryFieldFilterPathPlugin extends _Plugin.Plugin {
+  get fieldType() {
+    return this.config.fieldType;
+  }
+
+  constructor(config) {
+    super();
+    (0, _defineProperty2.default)(this, "config", void 0);
+    this.config = config;
+    this.name = `${this.constructor.type}-${this.config.fieldType}`;
+  }
+
+  canUse(field) {
+    if (field.type !== this.config.fieldType) {
+      return false;
+    }
+
+    if (Array.isArray(this.config.fieldId) === false || this.config.fieldId.length === 0) {
+      return true;
+    }
+
+    return this.config.fieldId.includes(field.fieldId);
+  }
+
+  createPath(params) {
+    if (typeof this.config.path === "function") {
+      return this.config.path(params);
+    } else if (typeof this.config.path === "string") {
+      return this.config.path;
+    }
+
+    throw new _error.default(`Missing path in "${this.name}" plugin.`);
+  }
+
+}
+
+exports.CmsEntryFieldFilterPathPlugin = CmsEntryFieldFilterPathPlugin;
+(0, _defineProperty2.default)(CmsEntryFieldFilterPathPlugin, "type", "cms-field-filter-path");

package/types.d.ts

@@ -25,36 +25,6 @@ export interface CmsFieldFilterValueTransformPlugin extends Plugin {
      */
     transform: (params: CmsFieldFilterValueTransformParams) => any;
 }
-interface CmsFieldFilterPathParams {
-    /**
-     * A field for which we are creating the value path.
-     */
-    field: CmsModelField;
-    /**
-     * If value is an array we will need index position.
-     * It is up to the developer to add.
-     */
-    index?: number | string;
-}
-export interface CmsFieldFilterPathPlugin extends Plugin {
-    /**
-     * A plugin type.
-     */
-    type: "cms-field-filter-path";
-    /**
-     * A field type this plugin is for.
-     */
-    fieldType: string;
-    /**
-     * A field id this plugin is for.
-     * It is meant for targeting only specific fields in a certain type.
-     */
-    fieldId?: string[];
-    /**
-     * Get a path for given field.
-     */
-    createPath: (params: CmsFieldFilterPathParams) => string;
-}
 export declare type AttributeDefinition = DynamoDBTypes | EntityAttributeConfig | EntityCompositeAttributes;
 export declare type Attributes = Record<string, AttributeDefinition>;
 export declare enum ENTITIES {

package/dynamoDb/path/ref.d.ts

@@ -1,3 +0,0 @@
-import { CmsFieldFilterPathPlugin } from "../../types";
-declare const _default: () => CmsFieldFilterPathPlugin;
-export default _default;

package/dynamoDb/path/ref.js

@@ -1,27 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _default = () => ({
-  type: "cms-field-filter-path",
-  name: "cms-field-filter-path-ref",
-  fieldType: "ref",
-  createPath: ({
-    field,
-    index
-  }) => {
-    const paths = [field.fieldId];
-
-    if (index !== undefined) {
-      paths.push(String(index));
-    }
-
-    paths.push("entryId");
-    return paths.join(".");
-  }
-});
-
-exports.default = _default;