@webiny/api-headless-cms-ddb 5.17.4 → 5.18.0-beta.3

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

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

package/operations/entry/systemFields.js

@@ -47,5 +47,4 @@ const systemFields = {
     }
   })
 };
-exports.systemFields = systemFields;
-//# sourceMappingURL=systemFields.js.map
+exports.systemFields = systemFields;

package/operations/entry/utils.d.ts

@@ -1,27 +1,31 @@
-import { CmsContentEntry, CmsContentEntryListWhere, CmsContentModel, CmsContentModelField } from "@webiny/api-headless-cms/types";
+import { CmsEntry, CmsEntryListWhere, CmsModel, CmsModelField } from "@webiny/api-headless-cms/types";
 import { PluginsContainer } from "@webiny/plugins";
 interface ModelField {
-    def: CmsContentModelField;
+    def: CmsModelField;
     valueTransformer: (value: any) => any;
     valuePath: string;
     isSystemField?: boolean;
 }
 declare type ModelFieldRecords = Record<string, ModelField>;
-interface FilterItemsArgs {
-    items: CmsContentEntry[];
-    where: CmsContentEntryListWhere;
+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: (args: FilterItemsArgs) => CmsContentEntry[];
+export declare const filterItems: (params: FilterItemsParams) => Promise<CmsEntry[]>;
 interface SortEntryItemsArgs {
-    items: CmsContentEntry[];
+    items: CmsEntry[];
     sort: string[];
     fields: ModelFieldRecords;
 }
-export declare const sortEntryItems: (args: SortEntryItemsArgs) => CmsContentEntry[];
+export declare const sortEntryItems: (params: SortEntryItemsArgs) => CmsEntry[];
 export declare const buildModelFields: ({ plugins, model }: {
     plugins: PluginsContainer;
-    model: CmsContentModel;
+    model: CmsModel;
 }) => Record<string, ModelField>;
 export {};

package/operations/entry/utils.js

@@ -19,7 +19,7 @@ var _ValueFilterPlugin = require("@webiny/db-dynamodb/plugins/definitions/ValueF
 
 const VALUES_ATTRIBUTE = "values";
 
-const extractWhereArgs = key => {
+const extractWhereParams = key => {
   const result = key.split("_");
   const fieldId = result.shift();
   const rawOp = result.length === 0 ? "eq" : result.join("_");
@@ -52,12 +52,12 @@ const transformValue = (value, transform) => {
   return transform(value);
 };
 
-const createFilters = args => {
+const createFilters = params => {
   const {
     where,
     plugins,
     fields
-  } = args;
+  } = params;
   const filterPlugins = getMappedPlugins({
     plugins,
     type: _ValueFilterPlugin.ValueFilterPlugin.type,
@@ -78,7 +78,7 @@ const createFilters = args => {
       fieldId,
       operation,
       negate
-    } = extractWhereArgs(key);
+    } = extractWhereParams(key);
     const field = fields[fieldId];
 
     if (!field) {
@@ -138,33 +138,78 @@ const createFilters = args => {
   });
 };
 
-const filterItems = args => {
+const filterItems = async params => {
   const {
     items,
     where,
     plugins,
-    fields
-  } = args;
+    fields,
+    fromStorage
+  } = params;
   const filters = createFilters({
     plugins,
     where,
     fields
   });
-  return items.filter(item => {
+  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 value = transformValue(_dotProp.default.get(item, filter.path), filter.transformValue);
+      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) {
-        return false;
+        passed = false;
+        break;
       }
     }
 
-    return true;
-  });
+    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;
@@ -196,12 +241,12 @@ const extractSort = (sortBy, fields) => {
   };
 };
 
-const sortEntryItems = args => {
+const sortEntryItems = params => {
   const {
     items,
     sort = [],
     fields
-  } = args;
+  } = params;
 
   if (items.length <= 1) {
     return items;
@@ -257,12 +302,12 @@ const sortEntryItems = args => {
 
 exports.sortEntryItems = sortEntryItems;
 
-const getMappedPlugins = args => {
+const getMappedPlugins = params => {
   const {
     plugins: pluginsContainer,
     type,
     property
-  } = args;
+  } = params;
   const plugins = pluginsContainer.byType(type);
 
   if (plugins.length === 0) {
@@ -358,5 +403,4 @@ const buildModelFields = ({
   }, fields);
 };
 
-exports.buildModelFields = buildModelFields;
-//# sourceMappingURL=utils.js.map
+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;

package/operations/group/index.js

@@ -0,0 +1,198 @@
+"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,3 +1,6 @@
-import { CmsContentModelStorageOperationsProvider } from "@webiny/api-headless-cms/types";
-declare const contentModelStorageOperationsProvider: () => CmsContentModelStorageOperationsProvider;
-export default contentModelStorageOperationsProvider;
+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;

package/operations/model/index.js

@@ -5,22 +5,157 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
-
-var _CmsContentModelDynamo = _interopRequireDefault(require("./CmsContentModelDynamo"));
-
-const contentModelStorageOperationsProvider = () => ({
-  type: "cms-content-model-storage-operations-provider",
-  name: "cms-content-model-storage-operations-ddb-crud",
-  provide: async ({
-    context
-  }) => {
-    return new _CmsContentModelDynamo.default({
-      context
-    });
-  }
-});
+exports.createModelsStorageOperations = 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");
+
+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#CM`;
+};
+
+const createSortKey = params => {
+  return params.modelId;
+};
+
+const createKeys = params => {
+  return {
+    PK: createPartitionKey(params),
+    SK: createSortKey(params)
+  };
+};
+
+const createType = () => {
+  return "cms.model";
+};
+
+const createModelsStorageOperations = params => {
+  const {
+    entity
+  } = params;
+
+  const create = async params => {
+    const {
+      model
+    } = params;
+    const keys = createKeys(model);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread(_objectSpread({}, model), keys), {}, {
+        TYPE: createType()
+      }));
+      return model;
+    } catch (ex) {
+      throw new _error.default(`Could not create CMS Content Model.`, "CREATE_MODEL_ERROR", {
+        error: ex,
+        model,
+        keys
+      });
+    }
+  };
+
+  const update = async params => {
+    const {
+      original,
+      model
+    } = params;
+    const keys = createKeys(model);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread(_objectSpread({}, model), keys), {}, {
+        TYPE: createType()
+      }));
+      return model;
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not update model.", ex.code || "MODEL_UPDATE_ERROR", {
+        error: ex,
+        model,
+        original,
+        keys
+      });
+    }
+  };
+
+  const deleteModel = async params => {
+    const {
+      model
+    } = params;
+    const keys = createKeys(model);
+
+    try {
+      await entity.delete(keys);
+      return model;
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not delete model.", ex.code || "MODEL_DELETE_ERROR", {
+        error: ex,
+        model,
+        keys
+      });
+    }
+  };
+
+  const get = async params => {
+    const keys = createKeys(params);
+
+    try {
+      const item = await (0, _get.get)({
+        entity,
+        keys
+      });
+      return (0, _cleanup.cleanupItem)(entity, item);
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not get model.", ex.code || "MODEL_GET_ERROR", {
+        error: ex,
+        keys
+      });
+    }
+  };
+
+  const list = async params => {
+    const {
+      where
+    } = params;
+    const queryAllParams = {
+      entity,
+      partitionKey: createPartitionKey(where),
+      options: {
+        gte: " "
+      }
+    };
+
+    try {
+      const items = await (0, _query.queryAll)(queryAllParams);
+      return (0, _cleanup.cleanupItems)(entity, items);
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not list models.", ex.code || "MODEL_LIST_ERROR", {
+        error: ex,
+        partitionKey: queryAllParams.partitionKey
+      });
+    }
+  };
+
+  return {
+    create,
+    update,
+    delete: deleteModel,
+    get,
+    list
+  };
+};
 
-var _default = contentModelStorageOperationsProvider;
-exports.default = _default;
-//# sourceMappingURL=index.js.map
+exports.createModelsStorageOperations = createModelsStorageOperations;