@webiny/api-headless-cms-ddb 0.0.0-mt-1

package/operations/entry/keys.d.ts

@@ -0,0 +1,25 @@
+interface BasePartitionKeyParams {
+    tenant: string;
+    locale: string;
+}
+export interface PartitionKeyParams extends BasePartitionKeyParams {
+    id: string;
+}
+export declare const createPartitionKey: (params: PartitionKeyParams) => string;
+export interface SortKeyParams {
+    version: number;
+}
+export declare const createRevisionSortKey: (params: SortKeyParams) => string;
+export declare const createLatestSortKey: () => string;
+export declare const createPublishedSortKey: () => string;
+export interface GSIPartitionKeyParams {
+    tenant: string;
+    locale: string;
+    modelId: string;
+}
+export declare const createGSIPartitionKey: (params: GSIPartitionKeyParams, type: "A" | "L" | "P") => string;
+export interface GSISortKeyParams {
+    id: string;
+}
+export declare const createGSISortKey: (params: GSISortKeyParams) => string;
+export {};

package/operations/entry/keys.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRevisionSortKey = exports.createPublishedSortKey = exports.createPartitionKey = exports.createLatestSortKey = exports.createGSISortKey = exports.createGSIPartitionKey = void 0;
+
+var _utils = require("@webiny/utils");
+
+const createBasePartitionKey = params => {
+  const {
+    tenant,
+    locale
+  } = params;
+  return `T#${tenant}#L#${locale}#CMS#CME`;
+};
+
+const createPartitionKey = params => {
+  const {
+    id: initialId
+  } = params;
+  const {
+    id
+  } = (0, _utils.parseIdentifier)(initialId);
+  return `${createBasePartitionKey(params)}#CME#${id}`;
+};
+
+exports.createPartitionKey = createPartitionKey;
+
+const createRevisionSortKey = params => {
+  return `REV#${(0, _utils.zeroPad)(params.version)}`;
+};
+
+exports.createRevisionSortKey = createRevisionSortKey;
+
+const createLatestSortKey = () => {
+  return "L";
+};
+
+exports.createLatestSortKey = createLatestSortKey;
+
+const createPublishedSortKey = () => {
+  return "P";
+};
+
+exports.createPublishedSortKey = createPublishedSortKey;
+
+const createGSIPartitionKey = (params, type) => {
+  const {
+    modelId
+  } = params;
+  const partitionKey = createBasePartitionKey(params);
+  return `${partitionKey}#M#${modelId}#${type}`;
+};
+
+exports.createGSIPartitionKey = createGSIPartitionKey;
+
+const createGSISortKey = params => {
+  return params.id;
+};
+
+exports.createGSISortKey = createGSISortKey;

package/operations/entry/systemFields.d.ts

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

package/operations/entry/systemFields.js

@@ -0,0 +1,50 @@
+"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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,406 @@
+"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

@@ -0,0 +1,8 @@
+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;