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

package/content/plugins/schema/resolvers/preview/resolveList.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveList = void 0;
+
+var _responses = require("@webiny/handler-graphql/responses");
+
+const resolveList = ({
+  model
+}) => async (_, args, {
+  cms
+}) => {
+  try {
+    const response = await cms.listLatestEntries(model, args);
+    return new _responses.ListResponse(...response);
+  } catch (e) {
+    return new _responses.ListErrorResponse(e);
+  }
+};
+
+exports.resolveList = resolveList;

package/content/plugins/schema/resolvers/read/resolveGet.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntryResolverFactory as ResolverFactory } from "../../../../../types";
+export declare const resolveGet: ResolverFactory;

package/content/plugins/schema/resolvers/read/resolveGet.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveGet = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _responses = require("@webiny/handler-graphql/responses");
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+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 resolveGet = ({
+  model
+}) => async (_, args, context) => {
+  try {
+    const [[entry]] = await context.cms.listPublishedEntries(model, _objectSpread(_objectSpread({}, args), {}, {
+      limit: 1
+    }));
+
+    if (!entry) {
+      throw new _handlerGraphql.NotFoundError(`Entry not found!`);
+    }
+
+    return new _responses.Response(entry);
+  } catch (e) {
+    return new _responses.ErrorResponse(e);
+  }
+};
+
+exports.resolveGet = resolveGet;

package/content/plugins/schema/resolvers/read/resolveList.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntryResolverFactory as ResolverFactory } from "../../../../../types";
+export declare const resolveList: ResolverFactory;

package/content/plugins/schema/resolvers/read/resolveList.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveList = void 0;
+
+var _responses = require("@webiny/handler-graphql/responses");
+
+const resolveList = ({
+  model
+}) => async (_, args, {
+  cms
+}) => {
+  try {
+    const response = await cms.listPublishedEntries(model, args);
+    return new _responses.ListResponse(...response);
+  } catch (e) {
+    return new _responses.ListErrorResponse(e);
+  }
+};
+
+exports.resolveList = resolveList;

package/content/plugins/schema/schemaPlugins.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLSchemaPlugin } from "@webiny/handler-graphql/plugins/GraphQLSchemaPlugin";
+import { CmsContext } from "../../../types";
+export declare const generateSchemaPlugins: (context: CmsContext) => Promise<GraphQLSchemaPlugin<CmsContext>[]>;

package/content/plugins/schema/schemaPlugins.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateSchemaPlugins = void 0;
+
+var _GraphQLSchemaPlugin = require("@webiny/handler-graphql/plugins/GraphQLSchemaPlugin");
+
+var _createManageSDL = require("./createManageSDL");
+
+var _createReadSDL = require("./createReadSDL");
+
+var _createManageResolvers = require("./createManageResolvers");
+
+var _createReadResolvers = require("./createReadResolvers");
+
+var _createPreviewResolvers = require("./createPreviewResolvers");
+
+var _getSchemaFromFieldPlugins = require("../utils/getSchemaFromFieldPlugins");
+
+const generateSchemaPlugins = async context => {
+  const {
+    plugins,
+    cms
+  } = context; // Structure plugins for faster access
+
+  const fieldTypePlugins = plugins.byType("cms-model-field-to-graphql").reduce((acc, pl) => {
+    acc[pl.fieldType] = pl;
+    return acc;
+  }, {}); // Load model data
+
+  context.security.disableAuthorization();
+  const models = await cms.listModels();
+  context.security.enableAuthorization();
+  const schemas = (0, _getSchemaFromFieldPlugins.getSchemaFromFieldPlugins)({
+    models,
+    fieldTypePlugins,
+    type: cms.type
+  });
+  const newPlugins = [];
+
+  for (const schema of schemas) {
+    newPlugins.push(new _GraphQLSchemaPlugin.GraphQLSchemaPlugin(schema));
+  }
+
+  models.filter(model => model.fields.length > 0).forEach(model => {
+    switch (cms.type) {
+      case "manage":
+        newPlugins.push(new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
+          typeDefs: (0, _createManageSDL.createManageSDL)({
+            model,
+            fieldTypePlugins
+          }),
+          resolvers: (0, _createManageResolvers.createManageResolvers)({
+            models,
+            model,
+            fieldTypePlugins,
+            context
+          })
+        }));
+        break;
+
+      case "preview":
+      case "read":
+        newPlugins.push(new _GraphQLSchemaPlugin.GraphQLSchemaPlugin({
+          typeDefs: (0, _createReadSDL.createReadSDL)({
+            model,
+            fieldTypePlugins
+          }),
+          resolvers: cms.READ ? (0, _createReadResolvers.createReadResolvers)({
+            models,
+            model,
+            fieldTypePlugins,
+            context
+          }) : (0, _createPreviewResolvers.createPreviewResolvers)({
+            models,
+            model,
+            fieldTypePlugins,
+            context
+          })
+        }));
+        break;
+
+      default:
+        return;
+    }
+  });
+  return newPlugins;
+};
+
+exports.generateSchemaPlugins = generateSchemaPlugins;

package/content/plugins/storage/StorageTransformPlugin.d.ts

@@ -0,0 +1,30 @@
+import { Plugin } from "@webiny/plugins/Plugin";
+import { CmsModel, CmsModelField } from "../../../types";
+import { PluginsContainer } from "@webiny/plugins";
+export interface ToStorageParams<T> {
+    model: CmsModel;
+    field: CmsModelField;
+    value: T;
+    getStoragePlugin(fieldType: string): StorageTransformPlugin<T>;
+    plugins: PluginsContainer;
+}
+export interface FromStorageParams<T> {
+    model: CmsModel;
+    field: CmsModelField;
+    value: T;
+    getStoragePlugin(fieldType: string): StorageTransformPlugin<T>;
+    plugins: PluginsContainer;
+}
+export interface Params<T, R> {
+    fieldType: string;
+    toStorage: (params: ToStorageParams<T>) => Promise<R>;
+    fromStorage: (params: FromStorageParams<R>) => Promise<T>;
+}
+export declare class StorageTransformPlugin<T = any, R = any> extends Plugin {
+    static readonly type: string;
+    get fieldType(): string;
+    private readonly config;
+    constructor(config: Params<T, R>);
+    toStorage(params: ToStorageParams<T>): Promise<R>;
+    fromStorage(params: FromStorageParams<R>): Promise<T>;
+}

package/content/plugins/storage/StorageTransformPlugin.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StorageTransformPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _Plugin = require("@webiny/plugins/Plugin");
+
+class StorageTransformPlugin extends _Plugin.Plugin {
+  get fieldType() {
+    return this.config.fieldType;
+  }
+
+  constructor(config) {
+    super();
+    (0, _defineProperty2.default)(this, "config", void 0);
+    this.config = config;
+  }
+
+  toStorage(params) {
+    return this.config.toStorage(params);
+  }
+
+  fromStorage(params) {
+    return this.config.fromStorage(params);
+  }
+
+}
+
+exports.StorageTransformPlugin = StorageTransformPlugin;
+(0, _defineProperty2.default)(StorageTransformPlugin, "type", "cms.storage.transform.plugin");

package/content/plugins/storage/default.d.ts

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

package/content/plugins/storage/default.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _StorageTransformPlugin = require("./StorageTransformPlugin");
+
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "*",
+  fromStorage: async ({
+    value
+  }) => {
+    return value;
+  },
+  toStorage: async ({
+    value
+  }) => {
+    return value;
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/content/plugins/storage/object.d.ts

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

package/content/plugins/storage/object.js

@@ -0,0 +1,119 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _pReduce = _interopRequireDefault(require("p-reduce"));
+
+var _pMap = _interopRequireDefault(require("p-map"));
+
+var _StorageTransformPlugin = require("./StorageTransformPlugin");
+
+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 processValue = async ({
+  fields,
+  sourceValue,
+  getStoragePlugin,
+  plugins,
+  model,
+  operation
+}) => {
+  return await (0, _pReduce.default)(fields, async (values, field) => {
+    const plugin = getStoragePlugin(field.type);
+    const value = await plugin[operation]({
+      plugins,
+      model,
+      field,
+      value: sourceValue[field.fieldId],
+      getStoragePlugin
+    });
+    return _objectSpread(_objectSpread({}, values), {}, {
+      [field.fieldId]: value
+    });
+  }, {});
+};
+
+const plugin = new _StorageTransformPlugin.StorageTransformPlugin({
+  fieldType: "object",
+  toStorage: async ({
+    field,
+    value,
+    getStoragePlugin,
+    model,
+    plugins
+  }) => {
+    if (!value) {
+      return null;
+    }
+
+    const fields = field.settings.fields;
+
+    if (field.multipleValues) {
+      return await (0, _pMap.default)(value, value => processValue({
+        sourceValue: value,
+        getStoragePlugin,
+        model,
+        plugins,
+        operation: "toStorage",
+        fields
+      }));
+    }
+
+    return processValue({
+      sourceValue: value,
+      getStoragePlugin,
+      model,
+      plugins,
+      operation: "toStorage",
+      fields
+    });
+  },
+  fromStorage: async ({
+    field,
+    value,
+    getStoragePlugin,
+    plugins,
+    model
+  }) => {
+    if (!value) {
+      return null;
+    }
+
+    const fields = field.settings.fields;
+
+    if (field.multipleValues) {
+      return (0, _pMap.default)(value, value => processValue({
+        sourceValue: value,
+        getStoragePlugin,
+        model,
+        plugins,
+        operation: "fromStorage",
+        fields
+      }));
+    }
+
+    return processValue({
+      sourceValue: value,
+      getStoragePlugin,
+      model,
+      plugins,
+      operation: "fromStorage",
+      fields
+    });
+  }
+});
+
+var _default = () => {
+  return plugin;
+};
+
+exports.default = _default;

package/content/plugins/utils/createTypeName.d.ts

@@ -0,0 +1,3 @@
+export declare const createTypeName: (modelId: string) => any;
+export declare const createReadTypeName: (baseTypeName: string) => any;
+export declare const createManageTypeName: (baseTypeName: string) => any;

package/content/plugins/utils/createTypeName.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTypeName = exports.createReadTypeName = exports.createManageTypeName = void 0;
+
+var _upperFirst = _interopRequireDefault(require("lodash/upperFirst"));
+
+const createTypeName = modelId => {
+  return (0, _upperFirst.default)(modelId);
+};
+
+exports.createTypeName = createTypeName;
+
+const createReadTypeName = baseTypeName => {
+  return createTypeName(baseTypeName);
+};
+
+exports.createReadTypeName = createReadTypeName;
+
+const createManageTypeName = baseTypeName => {
+  return createTypeName(baseTypeName);
+};
+
+exports.createManageTypeName = createManageTypeName;

package/content/plugins/utils/entryStorage.d.ts

@@ -0,0 +1,17 @@
+import { CmsEntry, CmsModel, CmsModelField, CmsContext } from "../../../types";
+/**
+ * A function that is used in crud to transform entry into the storage type.
+ */
+export declare const entryToStorageTransform: (context: CmsContext, model: CmsModel, entry: CmsEntry) => Promise<CmsEntry>;
+/**
+ * A function that is used to transform the whole entry from storage into its native form.
+ */
+export declare const entryFromStorageTransform: (context: CmsContext, model: CmsModel, entry?: CmsEntry & Record<string, any>) => Promise<CmsEntry>;
+interface EntryFieldFromStorageTransformParams {
+    context: CmsContext;
+    model: CmsModel;
+    field: CmsModelField;
+    value: any;
+}
+export declare const entryFieldFromStorageTransform: (params: EntryFieldFromStorageTransformParams) => Promise<any>;
+export {};

package/content/plugins/utils/entryStorage.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.entryToStorageTransform = exports.entryFromStorageTransform = exports.entryFieldFromStorageTransform = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _StorageTransformPlugin = require("../storage/StorageTransformPlugin");
+
+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 getStoragePluginFactory = context => {
+  let defaultStoragePlugin;
+  const plugins = context.plugins.byType(_StorageTransformPlugin.StorageTransformPlugin.type) // we reverse plugins because we want to get latest added only
+  .reverse().reduce((collection, plugin) => {
+    // check if it's a default plugin
+    if (plugin.fieldType === "*" && !defaultStoragePlugin) {
+      defaultStoragePlugin = plugin;
+      return collection;
+    }
+    /**
+     * either existing plugin added or plugin fieldType does not exist in current model
+     * this is to iterate a bit less later
+     */
+
+
+    if (!collection[plugin.fieldType]) {
+      collection[plugin.fieldType] = plugin;
+    }
+
+    return collection;
+  }, {});
+  return fieldType => {
+    return plugins[fieldType] || defaultStoragePlugin;
+  };
+};
+/**
+ * This should be used when transforming the whole entry.
+ */
+
+
+const entryStorageTransform = async (context, model, operation, entry) => {
+  const getStoragePlugin = getStoragePluginFactory(context);
+  const transformedValues = {};
+
+  for (const field of model.fields) {
+    const plugin = getStoragePlugin(field.type); // TODO: remove this once plugins are converted into classes
+
+    if (typeof plugin[operation] !== "function") {
+      throw new _error.default(`Missing "${operation}" function in storage plugin "${plugin.name}" for field type "${field.type}"`);
+    }
+
+    transformedValues[field.fieldId] = await plugin[operation]({
+      plugins: context.plugins,
+      model,
+      field,
+      value: entry.values[field.fieldId],
+      getStoragePlugin
+    });
+  }
+
+  return _objectSpread(_objectSpread({}, entry), {}, {
+    values: transformedValues
+  });
+};
+/**
+ * A function that is used in crud to transform entry into the storage type.
+ */
+
+
+const entryToStorageTransform = async (context, model, entry) => {
+  return entryStorageTransform(context, model, "toStorage", entry);
+};
+/**
+ * A function that is used to transform the whole entry from storage into its native form.
+ */
+
+
+exports.entryToStorageTransform = entryToStorageTransform;
+
+const entryFromStorageTransform = async (context, model, entry) => {
+  if (!entry) {
+    return null;
+  }
+
+  return entryStorageTransform(context, model, "fromStorage", entry);
+};
+
+exports.entryFromStorageTransform = entryFromStorageTransform;
+
+/*
+ * A function that is used to transform a single field from storage
+ */
+const entryFieldFromStorageTransform = async params => {
+  const {
+    context,
+    model,
+    field,
+    value
+  } = params;
+  const getStoragePlugin = getStoragePluginFactory(context);
+  const plugin = getStoragePlugin(field.type); // TODO: remove this once plugins are converted into classes
+
+  if (typeof plugin.fromStorage !== "function") {
+    throw new _error.default(`Missing "fromStorage" function in storage plugin "${plugin.name}" for field type "${field.type}"`);
+  }
+
+  return plugin.fromStorage({
+    plugins: context.plugins,
+    model,
+    field,
+    value,
+    getStoragePlugin
+  });
+};
+
+exports.entryFieldFromStorageTransform = entryFieldFromStorageTransform;

package/content/plugins/utils/getEntryTitle.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntry, CmsModel } from "../../../types";
+export declare function getEntryTitle(model: CmsModel, entry: CmsEntry): any;

package/content/plugins/utils/getEntryTitle.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getEntryTitle = getEntryTitle;
+
+function getEntryTitle(model, entry) {
+  if (!model.titleFieldId) {
+    return entry.id;
+  }
+
+  const titleValue = entry.values[model.titleFieldId];
+
+  if (!titleValue) {
+    return entry.id;
+  }
+
+  const field = model.fields.find(f => f.fieldId === model.titleFieldId);
+
+  if (!field) {
+    return titleValue;
+  }
+
+  const {
+    enabled = false,
+    values
+  } = field.predefinedValues || {};
+
+  if (!enabled || Array.isArray(values) === false) {
+    return titleValue;
+  }
+
+  for (const value of values) {
+    // needs to be loose because titleValue can be a number and value can be a string - but it must match
+    if (value.value == titleValue) {
+      return value.label;
+    }
+  }
+
+  return titleValue;
+}

package/content/plugins/utils/getSchemaFromFieldPlugins.d.ts

@@ -0,0 +1,11 @@
+import { CmsModel, CmsContext, CmsFieldTypePlugins } from "../../../types";
+import { GraphQLSchemaDefinition } from "@webiny/handler-graphql/types";
+interface RenderTypesFromFieldPlugins {
+    (params: {
+        models: CmsModel[];
+        fieldTypePlugins: CmsFieldTypePlugins;
+        type: string;
+    }): GraphQLSchemaDefinition<CmsContext>[];
+}
+export declare const getSchemaFromFieldPlugins: RenderTypesFromFieldPlugins;
+export {};

package/content/plugins/utils/getSchemaFromFieldPlugins.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSchemaFromFieldPlugins = void 0;
+const TYPE_MAP = {
+  preview: "read",
+  read: "read",
+  manage: "manage"
+};
+
+const getSchemaFromFieldPlugins = ({
+  models,
+  fieldTypePlugins,
+  type
+}) => {
+  return Object.values(fieldTypePlugins).map(pl => {
+    // Render gql types generated by field type plugins
+    if (typeof pl[TYPE_MAP[type]].createSchema === "function") {
+      return pl[TYPE_MAP[type]].createSchema({
+        models
+      });
+    }
+
+    return null;
+  }).filter(Boolean);
+};
+
+exports.getSchemaFromFieldPlugins = getSchemaFromFieldPlugins;