@webiny/api-headless-cms-ddb 0.0.0-mt-2 → 0.0.0-unstable.0156a4c312

package/operations/entry/systemFields.d.ts

@@ -1,2 +0,0 @@
-import { CmsModelField } from "@webiny/api-headless-cms/types";
-export declare const systemFields: Record<string, CmsModelField>;

package/operations/entry/systemFields.js

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.systemFields = void 0;
-
-const createSystemField = field => {
-  return field;
-};
-
-const systemFields = {
-  id: createSystemField({
-    id: "id",
-    type: "text",
-    fieldId: "id"
-  }),
-  entryId: createSystemField({
-    id: "entryId",
-    type: "text",
-    fieldId: "entryId"
-  }),
-  createdOn: createSystemField({
-    id: "createdOn",
-    type: "datetime",
-    fieldId: "createdOn"
-  }),
-  savedOn: createSystemField({
-    id: "savedOn",
-    type: "datetime",
-    fieldId: "savedOn"
-  }),
-  createdBy: createSystemField({
-    id: "createdBy",
-    type: "plainObject",
-    fieldId: "createdBy",
-    settings: {
-      path: "createdBy.id"
-    }
-  }),
-  ownedBy: createSystemField({
-    id: "ownedBy",
-    type: "plainObject",
-    fieldId: "ownedBy",
-    settings: {
-      path: "ownedBy.id"
-    }
-  })
-};
-exports.systemFields = systemFields;

package/operations/entry/utils.d.ts

@@ -1,31 +0,0 @@
-import { CmsEntry, CmsEntryListWhere, CmsModel, CmsModelField } from "@webiny/api-headless-cms/types";
-import { PluginsContainer } from "@webiny/plugins";
-interface ModelField {
-    def: CmsModelField;
-    valueTransformer: (value: any) => any;
-    valuePath: string;
-    isSystemField?: boolean;
-}
-declare type ModelFieldRecords = Record<string, ModelField>;
-export interface FilterItemFromStorage {
-    (field: CmsModelField, value: any): Promise<any>;
-}
-interface FilterItemsParams {
-    items: CmsEntry[];
-    where: CmsEntryListWhere;
-    plugins: PluginsContainer;
-    fields: ModelFieldRecords;
-    fromStorage: FilterItemFromStorage;
-}
-export declare const filterItems: (params: FilterItemsParams) => Promise<CmsEntry[]>;
-interface SortEntryItemsArgs {
-    items: CmsEntry[];
-    sort: string[];
-    fields: ModelFieldRecords;
-}
-export declare const sortEntryItems: (params: SortEntryItemsArgs) => CmsEntry[];
-export declare const buildModelFields: ({ plugins, model }: {
-    plugins: PluginsContainer;
-    model: CmsModel;
-}) => Record<string, ModelField>;
-export {};

package/operations/entry/utils.js

@@ -1,406 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sortEntryItems = exports.filterItems = exports.buildModelFields = void 0;
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _lodash = _interopRequireDefault(require("lodash.sortby"));
-
-var _dotProp = _interopRequireDefault(require("dot-prop"));
-
-var _systemFields = require("./systemFields");
-
-var _ValueFilterPlugin = require("@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin");
-
-const VALUES_ATTRIBUTE = "values";
-
-const extractWhereParams = key => {
-  const result = key.split("_");
-  const fieldId = result.shift();
-  const rawOp = result.length === 0 ? "eq" : result.join("_");
-  /**
-   * When rawOp is not, it means it is equal negated so just return that.
-   */
-
-  if (rawOp === "not") {
-    return {
-      fieldId,
-      operation: "eq",
-      negate: true
-    };
-  }
-
-  const negate = rawOp.match("not_") !== null;
-  const operation = rawOp.replace("not_", "");
-  return {
-    fieldId,
-    operation,
-    negate
-  };
-};
-
-const transformValue = (value, transform) => {
-  if (Array.isArray(value)) {
-    return value.map(v => transform(v));
-  }
-
-  return transform(value);
-};
-
-const createFilters = params => {
-  const {
-    where,
-    plugins,
-    fields
-  } = params;
-  const filterPlugins = getMappedPlugins({
-    plugins,
-    type: _ValueFilterPlugin.ValueFilterPlugin.type,
-    property: "operation"
-  });
-  const transformValuePlugins = getMappedPlugins({
-    plugins,
-    type: "cms-field-filter-value-transform",
-    property: "fieldType"
-  });
-  const valuePathPlugins = getMappedPlugins({
-    plugins,
-    type: "cms-field-filter-path",
-    property: "fieldType"
-  });
-  return Object.keys(where).map(key => {
-    const {
-      fieldId,
-      operation,
-      negate
-    } = extractWhereParams(key);
-    const field = fields[fieldId];
-
-    if (!field) {
-      throw new _error.default(`There is no field with the fieldId "${fieldId}".`, "FIELD_ERROR", {
-        fieldId
-      });
-    }
-
-    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) {
-        return value;
-      }
-
-      return transformValuePlugin.transform({
-        field: field.def,
-        value
-      });
-    };
-
-    return {
-      fieldId,
-      path: valuePath,
-      filterPlugin,
-      negate,
-      compareValue: transformValue(where[key], transformValueCallable),
-      transformValue: transformValueCallable
-    };
-  });
-};
-
-const filterItems = async params => {
-  const {
-    items,
-    where,
-    plugins,
-    fields,
-    fromStorage
-  } = params;
-  const filters = createFilters({
-    plugins,
-    where,
-    fields
-  });
-  const results = [];
-
-  for (const key in items) {
-    if (items.hasOwnProperty(key) === false) {
-      continue;
-    }
-
-    const item = items[key];
-    let passed = true;
-
-    for (const filter of filters) {
-      const rawValue = _dotProp.default.get(item, filter.path);
-
-      const plainValue = await fromStorage(fields[filter.fieldId].def, rawValue);
-      /**
-       * If raw value is not same as the value after the storage transform, set the value to the items being filtered.
-       */
-
-      if (plainValue !== rawValue) {
-        items[key] = _dotProp.default.set(item, filter.path, plainValue);
-      }
-
-      const value = transformValue(plainValue, filter.transformValue);
-      const matched = filter.filterPlugin.matches({
-        value,
-        compareValue: filter.compareValue
-      });
-
-      if ((filter.negate ? !matched : matched) === false) {
-        passed = false;
-        break;
-      }
-    }
-
-    if (!passed) {
-      continue;
-    }
-
-    results.push(item);
-  }
-
-  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;
-  // });
-};
-
-exports.filterItems = filterItems;
-
-const extractSort = (sortBy, fields) => {
-  const result = sortBy.split("_");
-
-  if (result.length !== 2) {
-    throw new _error.default("Problem in determining the sorting for the entry items.", "SORT_ERROR", {
-      sortBy
-    });
-  }
-
-  const [fieldId, order] = result;
-  const modelField = fields[fieldId];
-
-  if (!modelField) {
-    throw new _error.default("Sorting field does not exist in the content model.", "SORTING_FIELD_ERROR", {
-      fieldId,
-      fields
-    });
-  }
-
-  const valuePath = modelField.valuePath;
-  return {
-    fieldId,
-    valuePath,
-    reverse: order === "DESC"
-  };
-};
-
-const sortEntryItems = params => {
-  const {
-    items,
-    sort = [],
-    fields
-  } = params;
-
-  if (items.length <= 1) {
-    return items;
-  } else if (sort.length === 0) {
-    sort.push("savedOn_DESC");
-  } else if (sort.length > 1) {
-    throw new _error.default("Sorting is limited to a single field.", "SORT_ERROR", {
-      sort: sort
-    });
-  }
-
-  const [firstSort] = sort;
-
-  if (!firstSort) {
-    throw new _error.default("Empty sort array item.", "SORT_ERROR", {
-      sort
-    });
-  }
-
-  const {
-    fieldId,
-    valuePath,
-    reverse
-  } = extractSort(firstSort, fields);
-  const field = fields[fieldId];
-  const itemsToSort = items.map(item => {
-    return {
-      id: item.id,
-      value: field.valueTransformer(_dotProp.default.get(item, valuePath))
-    };
-  });
-  const sortedItems = (0, _lodash.default)(itemsToSort, "value");
-  const newItems = sortedItems.map(s => {
-    const item = items.find(i => i.id === s.id);
-
-    if (item) {
-      return item;
-    }
-
-    throw new _error.default("Could not find item by given id after the sorting.", "SORTING_ITEMS_ERROR", {
-      id: s.id,
-      sortingBy: fieldId,
-      reverse
-    });
-  });
-
-  if (!reverse) {
-    return newItems;
-  }
-
-  return newItems.reverse();
-};
-
-exports.sortEntryItems = sortEntryItems;
-
-const getMappedPlugins = params => {
-  const {
-    plugins: pluginsContainer,
-    type,
-    property
-  } = params;
-  const plugins = pluginsContainer.byType(type);
-
-  if (plugins.length === 0) {
-    throw new _error.default(`There are no plugins of type "${type}".`, "PLUGINS_ERROR", {
-      type
-    });
-  }
-
-  return plugins.reduce((collection, plugin) => {
-    const key = plugin[property];
-
-    if (typeof key !== "string") {
-      throw new _error.default("Property to map the plugins on must be a string.", "PLUGIN_PROPERTY_ERROR", {
-        type,
-        property
-      });
-    }
-
-    collection[key] = plugin;
-    return collection;
-  }, {});
-};
-
-const buildModelFields = ({
-  plugins,
-  model
-}) => {
-  const transformValuePlugins = getMappedPlugins({
-    plugins,
-    type: "cms-field-filter-value-transform",
-    property: "fieldType"
-  });
-  const valuePathPlugins = getMappedPlugins({
-    plugins,
-    type: "cms-field-filter-path",
-    property: "fieldType"
-  });
-  const fields = Object.values(_systemFields.systemFields).reduce((collection, field) => {
-    const transformValuePlugin = transformValuePlugins[field.type];
-    const valuePathPlugin = valuePathPlugins[field.type];
-    let valuePath;
-
-    if (valuePathPlugin) {
-      valuePath = valuePathPlugin.createPath({
-        field
-      });
-    }
-
-    collection[field.fieldId] = {
-      def: field,
-      valueTransformer: value => {
-        if (!transformValuePlugin) {
-          return value;
-        }
-
-        return transformValuePlugin.transform({
-          field,
-          value
-        });
-      },
-      valuePath: valuePath || field.fieldId,
-      isSystemField: true
-    };
-    return collection;
-  }, {});
-  return model.fields.reduce((collection, field) => {
-    const transformValuePlugin = transformValuePlugins[field.type];
-    const valuePathPlugin = valuePathPlugins[field.type];
-    let valuePath;
-
-    if (valuePathPlugin) {
-      valuePath = valuePathPlugin.createPath({
-        field
-      });
-    }
-
-    const targetValuePath = `${VALUES_ATTRIBUTE}.${valuePath || field.fieldId}`;
-    collection[field.fieldId] = {
-      def: field,
-      valueTransformer: value => {
-        if (!transformValuePlugin) {
-          return value;
-        }
-
-        return transformValuePlugin.transform({
-          field,
-          value
-        });
-      },
-      valuePath: targetValuePath || field.fieldId
-    };
-    return collection;
-  }, fields);
-};
-
-exports.buildModelFields = buildModelFields;

package/operations/group/index.d.ts

@@ -1,8 +0,0 @@
-import { CmsGroupStorageOperations } from "@webiny/api-headless-cms/types";
-import { Entity } from "dynamodb-toolbox";
-import { PluginsContainer } from "@webiny/plugins";
-export interface Params {
-    entity: Entity<any>;
-    plugins: PluginsContainer;
-}
-export declare const createGroupsStorageOperations: (params: Params) => CmsGroupStorageOperations;

package/operations/group/index.js

@@ -1,198 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createGroupsStorageOperations = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _error = _interopRequireDefault(require("@webiny/error"));
-
-var _get = require("@webiny/db-dynamodb/utils/get");
-
-var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
-
-var _query = require("@webiny/db-dynamodb/utils/query");
-
-var _filter = require("@webiny/db-dynamodb/utils/filter");
-
-var _ValueFilterPlugin = require("@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin");
-
-var _sort = require("@webiny/db-dynamodb/utils/sort");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-const createPartitionKey = params => {
-  const {
-    tenant,
-    locale
-  } = params;
-  return `T#${tenant}#L#${locale}#CMS#CMG`;
-};
-
-const createSortKeys = params => {
-  const {
-    id
-  } = params;
-  return id;
-};
-
-const createKeys = params => {
-  return {
-    PK: createPartitionKey(params),
-    SK: createSortKeys(params)
-  };
-};
-
-const createType = () => {
-  return "cms.group";
-};
-
-const createGroupsStorageOperations = params => {
-  const {
-    entity,
-    plugins
-  } = params;
-  const filteringPlugins = plugins.byType(_ValueFilterPlugin.ValueFilterPlugin.type);
-
-  if (filteringPlugins.length === 0) {
-    throw new _error.default("DynamoDB filtering plugins not loaded.", "MISSING_DYNAMODB_FILTERING_PLUGINS");
-  }
-
-  const create = async params => {
-    const {
-      group
-    } = params;
-    const keys = createKeys(group);
-
-    try {
-      await entity.put(_objectSpread(_objectSpread({}, group), {}, {
-        TYPE: createType()
-      }, keys));
-      return group;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not create group.", ex.code || "CREATE_GROUP_ERROR", {
-        error: ex,
-        group,
-        keys
-      });
-    }
-  };
-
-  const update = async params => {
-    const {
-      group,
-      original
-    } = params;
-    const keys = createKeys(group);
-
-    try {
-      await entity.put(_objectSpread(_objectSpread({}, group), {}, {
-        TYPE: createType()
-      }, keys));
-      return group;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not update group.", ex.code || "UPDATE_GROUP_ERROR", {
-        error: ex,
-        group,
-        original,
-        keys
-      });
-    }
-  };
-
-  const deleteGroup = async params => {
-    const {
-      group
-    } = params; // TODO make sure that group has locale and tenant on it - add it in the crud just in case
-
-    const keys = createKeys(group);
-
-    try {
-      await entity.delete(keys);
-      return group;
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not delete group.", ex.code || "DELETE_GROUP_ERROR", {
-        error: ex,
-        group,
-        keys
-      });
-    }
-  };
-
-  const get = async params => {
-    const keys = createKeys(params);
-
-    try {
-      const group = await (0, _get.get)({
-        entity,
-        keys
-      });
-      return (0, _cleanup.cleanupItem)(entity, group);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not get group.", ex.code || "GET_GROUP_ERROR", _objectSpread(_objectSpread({
-        error: ex
-      }, params), {}, {
-        keys
-      }));
-    }
-  };
-
-  const list = async params => {
-    const {
-      sort,
-      where
-    } = params;
-    const queryAllParams = {
-      entity,
-      partitionKey: createPartitionKey(where),
-      options: {
-        gte: " "
-      }
-    };
-    let records = [];
-
-    try {
-      records = await (0, _query.queryAll)(queryAllParams);
-    } catch (ex) {
-      throw new _error.default(ex.message || "Could not list groups.", ex.code || "LIST_GROUP_ERROR", _objectSpread(_objectSpread({
-        error: ex
-      }, params), {}, {
-        sort,
-        where
-      }));
-    }
-
-    const filteredItems = (0, _filter.filterItems)({
-      items: records,
-      where,
-      fields: [],
-      plugins
-    });
-
-    if (!sort || sort.length === 0) {
-      return filteredItems;
-    }
-
-    return (0, _sort.sortItems)({
-      items: filteredItems,
-      sort,
-      fields: []
-    });
-  };
-
-  return {
-    create,
-    update,
-    delete: deleteGroup,
-    get,
-    list
-  };
-};
-
-exports.createGroupsStorageOperations = createGroupsStorageOperations;

package/operations/model/index.d.ts

@@ -1,6 +0,0 @@
-import { CmsModelStorageOperations } from "@webiny/api-headless-cms/types";
-import { Entity } from "dynamodb-toolbox";
-export interface Params {
-    entity: Entity<any>;
-}
-export declare const createModelsStorageOperations: (params: Params) => CmsModelStorageOperations;