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

package/dynamoDb/storage/date.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _StorageTransformPlugin = require("@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin");
+
+const excludeTypes = ["time", "dateTimeWithTimezone"];
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "datetime",
+  fromStorage: async ({
+    value,
+    field
+  }) => {
+    const {
+      type
+    } = field.settings || {};
+
+    if (!value || !type || excludeTypes.includes(type)) {
+      return value;
+    }
+
+    try {
+      return new Date(value);
+    } catch {
+      console.log(`Could not transform from storage for field type`);
+      return value;
+    }
+  },
+  toStorage: async ({
+    value,
+    field
+  }) => {
+    const {
+      type
+    } = field.settings || {};
+
+    if (!value || !type || excludeTypes.includes(type)) {
+      return value;
+    }
+
+    if (value.toISOString) {
+      return value.toISOString();
+    } else if (typeof value === "string") {
+      return value;
+    }
+
+    throw new _error.default("Error converting value to a storage type.", "TO_STORAGE_ERROR", {
+      value,
+      fieldId: field.fieldId
+    });
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/dynamoDb/storage/longText.d.ts

@@ -0,0 +1,7 @@
+import { StorageTransformPlugin } from "@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin";
+export interface StorageValue {
+    compression: string;
+    value: any;
+}
+declare const _default: () => StorageTransformPlugin<string, StorageValue>;
+export default _default;

package/dynamoDb/storage/longText.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _gzip = require("@webiny/utils/compression/gzip");
+
+var _StorageTransformPlugin = require("@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin");
+
+const GZIP = "gzip";
+const TO_STORAGE_ENCODING = "base64";
+const FROM_STORAGE_ENCODING = "utf8";
+
+const convertToBuffer = value => {
+  if (typeof value === "string") {
+    return Buffer.from(value, TO_STORAGE_ENCODING);
+  }
+
+  return value;
+};
+
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "long-text",
+  fromStorage: async ({
+    field,
+    value: storageValue
+  }) => {
+    const typeOf = typeof storageValue;
+
+    if (!storageValue || typeOf === "string" || typeOf === "number") {
+      return storageValue;
+    } else if (typeof storageValue !== "object") {
+      throw new _error.default(`LongText value received in "fromStorage" function is not an object in field "${field.fieldId}".`);
+    }
+
+    const {
+      compression,
+      value
+    } = storageValue;
+    /**
+     * Check if possibly undefined, null, empty...
+     */
+
+    if (!compression) {
+      throw new _error.default(`Missing compression in "fromStorage" function in field "${field.fieldId}": ${JSON.stringify(storageValue)}.`, "MISSING_COMPRESSION", {
+        value: storageValue
+      });
+    } else if (compression !== GZIP) {
+      throw new _error.default(`This plugin cannot transform something not compressed with "GZIP".`, "WRONG_COMPRESSION", {
+        compression
+      });
+    }
+
+    try {
+      const buf = await (0, _gzip.decompress)(convertToBuffer(value));
+      return buf.toString(FROM_STORAGE_ENCODING);
+    } catch (ex) {
+      console.log(ex.message);
+      return null;
+    }
+  },
+  toStorage: async ({
+    value
+  }) => {
+    const compressedValue = await (0, _gzip.compress)(value);
+    return {
+      compression: GZIP,
+      value: compressedValue.toString(TO_STORAGE_ENCODING)
+    };
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/dynamoDb/storage/richText.d.ts

@@ -0,0 +1,8 @@
+import { StorageTransformPlugin } from "@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin";
+export declare type OriginalValue = Record<string, any> | any[];
+export interface StorageValue {
+    compression: string;
+    value: any;
+}
+declare const _default: () => StorageTransformPlugin<any, any>;
+export default _default;

package/dynamoDb/storage/richText.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _jsonpack = _interopRequireDefault(require("jsonpack"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _StorageTransformPlugin = require("@webiny/api-headless-cms/content/plugins/storage/StorageTransformPlugin");
+
+/**
+ * Remove when jsonpack gets PR with a fix merged
+ * https://github.com/rgcl/jsonpack/pull/25/files
+ * NOTE 2021-07-28: it seems PR is not going to be merged so keep this.
+ */
+const transformArray = value => {
+  if (!value) {
+    return value;
+  }
+
+  let isArray = Array.isArray(value);
+  const shouldBeArray = value instanceof Array === false && isArray;
+
+  if (shouldBeArray) {
+    value = Array.from(value);
+    isArray = true;
+  }
+
+  if (typeof value === "object" || isArray) {
+    for (const k in value) {
+      value[k] = transformArray(value[k]);
+    }
+  }
+
+  return value;
+};
+
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "rich-text",
+  fromStorage: async ({
+    field,
+    value: storageValue
+  }) => {
+    if (!storageValue) {
+      return storageValue;
+    } else if (typeof storageValue !== "object") {
+      throw new _error.default(`RichText value received in "fromStorage" function is not an object in field "${field.fieldId}".`);
+    }
+    /**
+     * This is to circumvent a bug introduced with 5.8.0 storage operations.
+     * Do not remove.
+     */
+
+
+    if (storageValue.hasOwnProperty("compression") === false) {
+      return storageValue;
+    }
+
+    const {
+      compression,
+      value
+    } = storageValue;
+
+    if (!compression) {
+      throw new _error.default(`Missing compression in "fromStorage" function in field "${field.fieldId}": ${JSON.stringify(storageValue)}.`, "MISSING_COMPRESSION", {
+        value: storageValue
+      });
+    }
+
+    if (compression !== "jsonpack") {
+      throw new _error.default(`This plugin cannot transform something not packed with "jsonpack".`, "WRONG_COMPRESSION", {
+        compression
+      });
+    }
+
+    try {
+      return _jsonpack.default.unpack(value);
+    } catch {
+      return null;
+    }
+  },
+  toStorage: async ({
+    value
+  }) => {
+    /**
+     * There is a possibility that we are trying to compress already compressed value.
+     * Introduced a bug with 5.8.0 storage operations, so just return the value to correct it.
+     */
+    if (value && value.hasOwnProperty("compression") === true) {
+      return value;
+    }
+
+    value = transformArray(value);
+    return {
+      compression: "jsonpack",
+      value: value ? _jsonpack.default.pack(value) : value
+    };
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/dynamoDb/transformValue/datetime.d.ts

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

package/dynamoDb/transformValue/datetime.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _TimeTransformPlugin = require("@webiny/db-dynamodb/plugins/definitions/TimeTransformPlugin");
+
+var _DateTimeTransformPlugin = require("@webiny/db-dynamodb/plugins/definitions/DateTimeTransformPlugin");
+
+const timeTransformer = new _TimeTransformPlugin.TimeTransformPlugin({
+  fields: ["*"]
+});
+const dateTimeTransformer = new _DateTimeTransformPlugin.DateTimeTransformPlugin({
+  fields: ["*"]
+});
+
+var _default = () => ({
+  type: "cms-field-filter-value-transform",
+  name: "cms-field-value-filter-transform-datetime",
+  fieldType: "datetime",
+
+  /**
+   * Always transform into the milliseconds.
+   */
+  transform: ({
+    field,
+    value
+  }) => {
+    const {
+      type
+    } = field.settings || {};
+
+    if (type === "time") {
+      return timeTransformer.transform({
+        value
+      });
+    }
+
+    return dateTimeTransformer.transform({
+      value
+    });
+  }
+});
+
+exports.default = _default;

package/index.d.ts

@@ -0,0 +1,2 @@
+import { StorageOperationsFactory } from "./types";
+export declare const createStorageOperations: StorageOperationsFactory;

package/index.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStorageOperations = void 0;
+
+var _filters = _interopRequireDefault(require("@webiny/db-dynamodb/plugins/filters"));
+
+var _dynamoDb = _interopRequireDefault(require("./dynamoDb"));
+
+var _types = require("./types");
+
+var _table = require("./definitions/table");
+
+var _settings = require("./definitions/settings");
+
+var _system = require("./definitions/system");
+
+var _group = require("./definitions/group");
+
+var _model = require("./definitions/model");
+
+var _entry = require("./definitions/entry");
+
+var _plugins = require("@webiny/plugins");
+
+var _system2 = require("./operations/system");
+
+var _settings2 = require("./operations/settings");
+
+var _group2 = require("./operations/group");
+
+var _model2 = require("./operations/model");
+
+var _entry2 = require("./operations/entry");
+
+const createStorageOperations = params => {
+  const {
+    attributes = {},
+    table,
+    documentClient,
+    plugins: customPlugins,
+    modelFieldToGraphQLPlugins
+  } = params;
+  const tableInstance = (0, _table.createTable)({
+    table,
+    documentClient
+  });
+  const entities = {
+    settings: (0, _settings.createSettingsEntity)({
+      entityName: _types.ENTITIES.SETTINGS,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.SETTINGS]
+    }),
+    system: (0, _system.createSystemEntity)({
+      entityName: _types.ENTITIES.SYSTEM,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.SYSTEM]
+    }),
+    groups: (0, _group.createGroupEntity)({
+      entityName: _types.ENTITIES.GROUPS,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.GROUPS]
+    }),
+    models: (0, _model.createModelEntity)({
+      entityName: _types.ENTITIES.MODELS,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.MODELS]
+    }),
+    entries: (0, _entry.createEntryEntity)({
+      entityName: _types.ENTITIES.ENTRIES,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.ENTRIES]
+    })
+  };
+  const plugins = new _plugins.PluginsContainer([
+  /**
+   * User defined custom plugins.
+   */
+  ...(customPlugins || []),
+  /**
+   * Plugins of type CmsModelFieldToGraphQLPlugin.
+   */
+  modelFieldToGraphQLPlugins,
+  /**
+   * DynamoDB filter plugins for the where conditions.
+   */
+  (0, _filters.default)(),
+  /**
+   * Field plugins for DynamoDB.
+   */
+  (0, _dynamoDb.default)()]);
+  return {
+    plugins: [
+    /**
+     * Field plugins for DynamoDB.
+     * We must pass them to the base application.
+     */
+    (0, _dynamoDb.default)()],
+    getEntities: () => entities,
+    getTable: () => tableInstance,
+    system: (0, _system2.createSystemStorageOperations)({
+      entity: entities.system
+    }),
+    settings: (0, _settings2.createSettingsStorageOperations)({
+      entity: entities.settings
+    }),
+    groups: (0, _group2.createGroupsStorageOperations)({
+      entity: entities.groups,
+      plugins
+    }),
+    models: (0, _model2.createModelsStorageOperations)({
+      entity: entities.models
+    }),
+    entries: (0, _entry2.createEntriesStorageOperations)({
+      entity: entities.entries,
+      plugins
+    })
+  };
+};
+
+exports.createStorageOperations = createStorageOperations;

package/operations/entry/dataLoaders.d.ts

@@ -0,0 +1,38 @@
+import { CmsEntry, CmsModel } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+export interface GetAllEntryRevisionsParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+export interface GetRevisionByIdParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+export interface GetPublishedRevisionByEntryIdParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+export interface GetLatestRevisionByEntryIdParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+interface ClearLoaderParams {
+    model: CmsModel;
+    entry?: CmsEntry;
+}
+export interface Params {
+    entity: Entity<any>;
+}
+export declare class DataLoadersHandler {
+    private readonly loaders;
+    private readonly entity;
+    constructor(params: any);
+    getAllEntryRevisions(params: GetAllEntryRevisionsParams): Promise<CmsEntry[]>;
+    getRevisionById(params: GetRevisionByIdParams): Promise<CmsEntry[]>;
+    getPublishedRevisionByEntryId(params: GetPublishedRevisionByEntryIdParams): Promise<CmsEntry[]>;
+    getLatestRevisionByEntryId(params: GetLatestRevisionByEntryIdParams): Promise<CmsEntry[]>;
+    private getLoader;
+    private loadMany;
+    clearAll(params: Omit<ClearLoaderParams, "entry">): void;
+}
+export {};