@webiny/api-headless-cms 0.0.0-mt-3 → 0.0.0-unstable.40876133bb

package/utils/filterModelFields.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterModelsDeletedFields = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+/**
+ * We are leaving this file because isDeleted might come back later
+ */
+// @ts-nocheck
+
+/**
+ * Filters deleted fields from the list of fields.
+ *
+ * Used to recursively delete fields - object field.
+ */
+const filterDeletedFields = params => {
+  return params.fields.reduce((output, field) => {
+    var _field$settings;
+
+    if (!!field.isDeleted) {
+      return output;
+    } else if ((_field$settings = field.settings) !== null && _field$settings !== void 0 && _field$settings.fields) {
+      const fields = filterDeletedFields({
+        fields: field.settings.fields
+      });
+      output.push((0, _objectSpread2.default)((0, _objectSpread2.default)({}, field), {}, {
+        settings: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, field.settings), {}, {
+          fields
+        })
+      }));
+      return output;
+    }
+
+    output.push(field);
+    return output;
+  }, []);
+};
+/**
+ * Filters deleted fields from given model.
+ */
+
+
+const filterModelDeletedFields = ({
+  model
+}) => {
+  const fields = filterDeletedFields(model);
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, model), {}, {
+    fields
+  });
+};
+/**
+ * Filters deleted fields from all given models.
+ */
+
+
+const filterModelsDeletedFields = ({
+  models,
+  type
+}) => {
+  if (type === "manage") {
+    return models;
+  }
+
+  return models.map(model => {
+    return filterModelDeletedFields({
+      model
+    });
+  });
+};
+
+exports.filterModelsDeletedFields = filterModelsDeletedFields;

package/utils/filterModelFields.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["filterDeletedFields","params","fields","reduce","output","field","isDeleted","settings","push","filterModelDeletedFields","model","filterModelsDeletedFields","models","type","map"],"sources":["filterModelFields.ts"],"sourcesContent":["/**\n * We are leaving this file because isDeleted might come back later\n */\n// @ts-nocheck\nimport { ApiEndpoint, CmsModel, CmsModelField } from \"~/types\";\n\n/**\n * Filters deleted fields from the list of fields.\n *\n * Used to recursively delete fields - object field.\n */\ninterface FilterModelFieldsCallableParams {\n    fields: CmsModelField[];\n}\ninterface FilterModelFieldsCallable {\n    (params: FilterModelFieldsCallableParams): CmsModelField[];\n}\n\nconst filterDeletedFields: FilterModelFieldsCallable = params => {\n    return params.fields.reduce<CmsModelField[]>((output, field) => {\n        if (!!field.isDeleted) {\n            return output;\n        } else if (field.settings?.fields) {\n            const fields = filterDeletedFields({\n                fields: field.settings.fields\n            });\n\n            output.push({\n                ...field,\n                settings: {\n                    ...field.settings,\n                    fields\n                }\n            });\n            return output;\n        }\n\n        output.push(field);\n\n        return output;\n    }, []);\n};\n\n/**\n * Filters deleted fields from given model.\n */\ninterface FilterModelDeletedFieldsCallableParams {\n    model: CmsModel;\n}\ninterface FilterModelDeletedFieldsCallable {\n    (params: FilterModelDeletedFieldsCallableParams): CmsModel;\n}\nconst filterModelDeletedFields: FilterModelDeletedFieldsCallable = ({ model }) => {\n    const fields = filterDeletedFields(model);\n    return {\n        ...model,\n        fields\n    };\n};\n\n/**\n * Filters deleted fields from all given models.\n */\ninterface FilterModelsDeletedFieldsCallableParams {\n    models: CmsModel[];\n    type: ApiEndpoint;\n}\ninterface FilterModelsDeletedFieldsCallable {\n    (params: FilterModelsDeletedFieldsCallableParams): CmsModel[];\n}\nexport const filterModelsDeletedFields: FilterModelsDeletedFieldsCallable = ({ models, type }) => {\n    if (type === \"manage\") {\n        return models;\n    }\n    return models.map(model => {\n        return filterModelDeletedFields({\n            model\n        });\n    });\n};\n"],"mappings":";;;;;;;;;;;AAAA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AAQA,MAAMA,mBAA8C,GAAGC,MAAM,IAAI;EAC7D,OAAOA,MAAM,CAACC,MAAP,CAAcC,MAAd,CAAsC,CAACC,MAAD,EAASC,KAAT,KAAmB;IAAA;;IAC5D,IAAI,CAAC,CAACA,KAAK,CAACC,SAAZ,EAAuB;MACnB,OAAOF,MAAP;IACH,CAFD,MAEO,uBAAIC,KAAK,CAACE,QAAV,4CAAI,gBAAgBL,MAApB,EAA4B;MAC/B,MAAMA,MAAM,GAAGF,mBAAmB,CAAC;QAC/BE,MAAM,EAAEG,KAAK,CAACE,QAAN,CAAeL;MADQ,CAAD,CAAlC;MAIAE,MAAM,CAACI,IAAP,6DACOH,KADP;QAEIE,QAAQ,8DACDF,KAAK,CAACE,QADL;UAEJL;QAFI;MAFZ;MAOA,OAAOE,MAAP;IACH;;IAEDA,MAAM,CAACI,IAAP,CAAYH,KAAZ;IAEA,OAAOD,MAAP;EACH,CArBM,EAqBJ,EArBI,CAAP;AAsBH,CAvBD;AAyBA;AACA;AACA;;;AAOA,MAAMK,wBAA0D,GAAG,CAAC;EAAEC;AAAF,CAAD,KAAe;EAC9E,MAAMR,MAAM,GAAGF,mBAAmB,CAACU,KAAD,CAAlC;EACA,mEACOA,KADP;IAEIR;EAFJ;AAIH,CAND;AAQA;AACA;AACA;;;AAQO,MAAMS,yBAA4D,GAAG,CAAC;EAAEC,MAAF;EAAUC;AAAV,CAAD,KAAsB;EAC9F,IAAIA,IAAI,KAAK,QAAb,EAAuB;IACnB,OAAOD,MAAP;EACH;;EACD,OAAOA,MAAM,CAACE,GAAP,CAAWJ,KAAK,IAAI;IACvB,OAAOD,wBAAwB,CAAC;MAC5BC;IAD4B,CAAD,CAA/B;EAGH,CAJM,CAAP;AAKH,CATM"}

package/utils/getEntryTitle.d.ts

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

package/{content/plugins/utils → utils}/getEntryTitle.js

@@ -10,16 +10,17 @@ function getEntryTitle(model, entry) {
     return entry.id;
   }
 
-  const titleValue = entry.values[model.titleFieldId];
+  const field = model.fields.find(f => f.fieldId === model.titleFieldId);
 
-  if (!titleValue) {
+  if (!field) {
     return entry.id;
   }
 
-  const field = model.fields.find(f => f.fieldId === model.titleFieldId);
+  const titleFieldId = field.fieldId;
+  const titleValue = entry.values[titleFieldId];
 
-  if (!field) {
-    return titleValue;
+  if (!titleValue) {
+    return entry.id;
   }
 
   const {
@@ -27,7 +28,7 @@ function getEntryTitle(model, entry) {
     values
   } = field.predefinedValues || {};
 
-  if (!enabled || Array.isArray(values) === false) {
+  if (!enabled || !values || Array.isArray(values) === false) {
     return titleValue;
   }
 

package/utils/getEntryTitle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getEntryTitle","model","entry","titleFieldId","id","field","fields","find","f","fieldId","titleValue","values","enabled","predefinedValues","Array","isArray","value","label"],"sources":["getEntryTitle.ts"],"sourcesContent":["import { CmsEntry, CmsModel } from \"~/types\";\n\nexport function getEntryTitle(model: CmsModel, entry: CmsEntry): string {\n    if (!model.titleFieldId) {\n        return entry.id;\n    }\n    const field = model.fields.find(f => f.fieldId === model.titleFieldId);\n    if (!field) {\n        return entry.id;\n    }\n    const titleFieldId = field.fieldId;\n    const titleValue = entry.values[titleFieldId];\n    if (!titleValue) {\n        return entry.id;\n    }\n\n    const { enabled = false, values } = field.predefinedValues || {};\n    if (!enabled || !values || Array.isArray(values) === false) {\n        return titleValue;\n    }\n    for (const value of values) {\n        // needs to be loose because titleValue can be a number and value can be a string - but it must match\n        if (value.value == titleValue) {\n            return value.label;\n        }\n    }\n    return titleValue;\n}\n"],"mappings":";;;;;;;AAEO,SAASA,aAAT,CAAuBC,KAAvB,EAAwCC,KAAxC,EAAiE;EACpE,IAAI,CAACD,KAAK,CAACE,YAAX,EAAyB;IACrB,OAAOD,KAAK,CAACE,EAAb;EACH;;EACD,MAAMC,KAAK,GAAGJ,KAAK,CAACK,MAAN,CAAaC,IAAb,CAAkBC,CAAC,IAAIA,CAAC,CAACC,OAAF,KAAcR,KAAK,CAACE,YAA3C,CAAd;;EACA,IAAI,CAACE,KAAL,EAAY;IACR,OAAOH,KAAK,CAACE,EAAb;EACH;;EACD,MAAMD,YAAY,GAAGE,KAAK,CAACI,OAA3B;EACA,MAAMC,UAAU,GAAGR,KAAK,CAACS,MAAN,CAAaR,YAAb,CAAnB;;EACA,IAAI,CAACO,UAAL,EAAiB;IACb,OAAOR,KAAK,CAACE,EAAb;EACH;;EAED,MAAM;IAAEQ,OAAO,GAAG,KAAZ;IAAmBD;EAAnB,IAA8BN,KAAK,CAACQ,gBAAN,IAA0B,EAA9D;;EACA,IAAI,CAACD,OAAD,IAAY,CAACD,MAAb,IAAuBG,KAAK,CAACC,OAAN,CAAcJ,MAAd,MAA0B,KAArD,EAA4D;IACxD,OAAOD,UAAP;EACH;;EACD,KAAK,MAAMM,KAAX,IAAoBL,MAApB,EAA4B;IACxB;IACA,IAAIK,KAAK,CAACA,KAAN,IAAeN,UAAnB,EAA+B;MAC3B,OAAOM,KAAK,CAACC,KAAb;IACH;EACJ;;EACD,OAAOP,UAAP;AACH"}

package/utils/getSchemaFromFieldPlugins.d.ts

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

package/utils/getSchemaFromFieldPlugins.js

@@ -0,0 +1,35 @@
+"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(plugin => {
+    if (!TYPE_MAP[type] || !plugin[TYPE_MAP[type]]) {
+      return null;
+    }
+
+    const createSchema = plugin[TYPE_MAP[type]].createSchema; // Render gql types generated by field type plugins
+
+    if (!createSchema) {
+      return null;
+    }
+
+    return createSchema({
+      models
+    });
+  }).filter(Boolean);
+};
+
+exports.getSchemaFromFieldPlugins = getSchemaFromFieldPlugins;

package/utils/getSchemaFromFieldPlugins.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TYPE_MAP","preview","read","manage","getSchemaFromFieldPlugins","models","fieldTypePlugins","type","Object","values","map","plugin","createSchema","filter","Boolean"],"sources":["getSchemaFromFieldPlugins.ts"],"sourcesContent":["import { CmsModel, CmsContext, CmsFieldTypePlugins, ApiEndpoint } from \"~/types\";\nimport { GraphQLSchemaDefinition } from \"@webiny/handler-graphql/types\";\n\ninterface RenderTypesFromFieldPluginsParams {\n    models: CmsModel[];\n    fieldTypePlugins: CmsFieldTypePlugins;\n    type: ApiEndpoint;\n}\ninterface RenderTypesFromFieldPlugins {\n    (params: RenderTypesFromFieldPluginsParams): GraphQLSchemaDefinition<CmsContext>[];\n}\n\nconst TYPE_MAP: Record<string, \"manage\" | \"read\"> = {\n    preview: \"read\",\n    read: \"read\",\n    manage: \"manage\"\n};\n\nexport const getSchemaFromFieldPlugins: RenderTypesFromFieldPlugins = ({\n    models,\n    fieldTypePlugins,\n    type\n}) => {\n    return Object.values(fieldTypePlugins)\n        .map(plugin => {\n            if (!TYPE_MAP[type] || !plugin[TYPE_MAP[type]]) {\n                return null;\n            }\n            const createSchema = plugin[TYPE_MAP[type]].createSchema;\n            // Render gql types generated by field type plugins\n            if (!createSchema) {\n                return null;\n            }\n            return createSchema({ models });\n        })\n        .filter(Boolean) as GraphQLSchemaDefinition<CmsContext>[];\n};\n"],"mappings":";;;;;;AAYA,MAAMA,QAA2C,GAAG;EAChDC,OAAO,EAAE,MADuC;EAEhDC,IAAI,EAAE,MAF0C;EAGhDC,MAAM,EAAE;AAHwC,CAApD;;AAMO,MAAMC,yBAAsD,GAAG,CAAC;EACnEC,MADmE;EAEnEC,gBAFmE;EAGnEC;AAHmE,CAAD,KAIhE;EACF,OAAOC,MAAM,CAACC,MAAP,CAAcH,gBAAd,EACFI,GADE,CACEC,MAAM,IAAI;IACX,IAAI,CAACX,QAAQ,CAACO,IAAD,CAAT,IAAmB,CAACI,MAAM,CAACX,QAAQ,CAACO,IAAD,CAAT,CAA9B,EAAgD;MAC5C,OAAO,IAAP;IACH;;IACD,MAAMK,YAAY,GAAGD,MAAM,CAACX,QAAQ,CAACO,IAAD,CAAT,CAAN,CAAuBK,YAA5C,CAJW,CAKX;;IACA,IAAI,CAACA,YAAL,EAAmB;MACf,OAAO,IAAP;IACH;;IACD,OAAOA,YAAY,CAAC;MAAEP;IAAF,CAAD,CAAnB;EACH,CAXE,EAYFQ,MAZE,CAYKC,OAZL,CAAP;AAaH,CAlBM"}

package/utils/ownership.d.ts

@@ -0,0 +1,8 @@
+import { BaseCmsSecurityPermission, CmsContext, CreatedBy } from "../types";
+interface OwnableRecord {
+    createdBy?: CreatedBy;
+    ownedBy?: CreatedBy;
+}
+export declare const checkOwnership: (context: CmsContext, permission: BaseCmsSecurityPermission, record: OwnableRecord) => void;
+export declare const validateOwnership: (context: CmsContext, permission: BaseCmsSecurityPermission, record: OwnableRecord) => boolean;
+export {};

package/utils/ownership.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateOwnership = exports.checkOwnership = void 0;
+
+var _apiSecurity = require("@webiny/api-security");
+
+const checkOwnership = (context, permission, record) => {
+  var _record$ownedBy, _record$createdBy;
+
+  if (!permission.own) {
+    return;
+  }
+
+  const identity = context.security.getIdentity();
+  const owner = identity && ((_record$ownedBy = record.ownedBy) === null || _record$ownedBy === void 0 ? void 0 : _record$ownedBy.id) === identity.id;
+  const creator = identity && ((_record$createdBy = record.createdBy) === null || _record$createdBy === void 0 ? void 0 : _record$createdBy.id) === identity.id;
+
+  if (!owner && !creator) {
+    throw new _apiSecurity.NotAuthorizedError({
+      data: {
+        reason: `You are not the owner of the record.`
+      }
+    });
+  }
+};
+
+exports.checkOwnership = checkOwnership;
+
+const validateOwnership = (context, permission, record) => {
+  try {
+    checkOwnership(context, permission, record);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+exports.validateOwnership = validateOwnership;

package/utils/ownership.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["checkOwnership","context","permission","record","own","identity","security","getIdentity","owner","ownedBy","id","creator","createdBy","NotAuthorizedError","data","reason","validateOwnership"],"sources":["ownership.ts"],"sourcesContent":["import { BaseCmsSecurityPermission, CmsContext, CreatedBy } from \"~/types\";\nimport { NotAuthorizedError } from \"@webiny/api-security\";\n\ninterface OwnableRecord {\n    createdBy?: CreatedBy;\n    ownedBy?: CreatedBy;\n}\n\nexport const checkOwnership = (\n    context: CmsContext,\n    permission: BaseCmsSecurityPermission,\n    record: OwnableRecord\n): void => {\n    if (!permission.own) {\n        return;\n    }\n\n    const identity = context.security.getIdentity();\n    const owner = identity && record.ownedBy?.id === identity.id;\n    const creator = identity && record.createdBy?.id === identity.id;\n\n    if (!owner && !creator) {\n        throw new NotAuthorizedError({\n            data: {\n                reason: `You are not the owner of the record.`\n            }\n        });\n    }\n};\n\nexport const validateOwnership = (\n    context: CmsContext,\n    permission: BaseCmsSecurityPermission,\n    record: OwnableRecord\n): boolean => {\n    try {\n        checkOwnership(context, permission, record);\n        return true;\n    } catch {\n        return false;\n    }\n};\n"],"mappings":";;;;;;;AACA;;AAOO,MAAMA,cAAc,GAAG,CAC1BC,OAD0B,EAE1BC,UAF0B,EAG1BC,MAH0B,KAInB;EAAA;;EACP,IAAI,CAACD,UAAU,CAACE,GAAhB,EAAqB;IACjB;EACH;;EAED,MAAMC,QAAQ,GAAGJ,OAAO,CAACK,QAAR,CAAiBC,WAAjB,EAAjB;EACA,MAAMC,KAAK,GAAGH,QAAQ,IAAI,oBAAAF,MAAM,CAACM,OAAP,oEAAgBC,EAAhB,MAAuBL,QAAQ,CAACK,EAA1D;EACA,MAAMC,OAAO,GAAGN,QAAQ,IAAI,sBAAAF,MAAM,CAACS,SAAP,wEAAkBF,EAAlB,MAAyBL,QAAQ,CAACK,EAA9D;;EAEA,IAAI,CAACF,KAAD,IAAU,CAACG,OAAf,EAAwB;IACpB,MAAM,IAAIE,+BAAJ,CAAuB;MACzBC,IAAI,EAAE;QACFC,MAAM,EAAG;MADP;IADmB,CAAvB,CAAN;EAKH;AACJ,CApBM;;;;AAsBA,MAAMC,iBAAiB,GAAG,CAC7Bf,OAD6B,EAE7BC,UAF6B,EAG7BC,MAH6B,KAInB;EACV,IAAI;IACAH,cAAc,CAACC,OAAD,EAAUC,UAAV,EAAsBC,MAAtB,CAAd;IACA,OAAO,IAAP;EACH,CAHD,CAGE,MAAM;IACJ,OAAO,KAAP;EACH;AACJ,CAXM"}

package/utils/permissions.d.ts

@@ -0,0 +1,7 @@
+import { BaseCmsSecurityPermission, CmsContext, CmsEntryPermission } from "../types";
+export declare const hasRwd: (permission: BaseCmsSecurityPermission, rwd: string) => boolean;
+export declare const hasPw: (permission: CmsEntryPermission, pw: string) => boolean;
+export declare const checkPermissions: <TPermission extends BaseCmsSecurityPermission = BaseCmsSecurityPermission>(context: CmsContext, name: string, check?: {
+    rwd?: string;
+    pw?: string;
+}) => Promise<TPermission>;

package/utils/permissions.js

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasRwd = exports.hasPw = exports.checkPermissions = void 0;
+
+var _apiSecurity = require("@webiny/api-security");
+
+const hasRwd = (permission, rwd) => {
+  if (typeof permission.rwd !== "string") {
+    return true;
+  }
+
+  return permission.rwd.includes(rwd);
+};
+
+exports.hasRwd = hasRwd;
+
+const hasPw = (permission, pw) => {
+  const isCustom = Object.keys(permission).length > 1; // "name" key is always present
+
+  if (!isCustom) {
+    // Means it's a "full-access" permission.
+    return true;
+  }
+
+  if (typeof permission.pw !== "string") {
+    return false;
+  }
+
+  return permission.pw.includes(pw);
+};
+
+exports.hasPw = hasPw;
+const PW = {
+  p: "publish",
+  u: "unpublish"
+};
+const RWD = {
+  r: "read",
+  w: "write",
+  d: "delete"
+};
+
+const checkPermissions = async (context, name, check) => {
+  // Check if user is allowed to edit content in current language
+  const contentPermission = await context.security.getPermission("content.i18n");
+
+  if (!contentPermission) {
+    throw new _apiSecurity.NotAuthorizedError({
+      data: {
+        reason: "Missing access to content in any locale."
+      }
+    });
+  } // We need to check this manually as CMS locale comes from the URL and not the default i18n app.
+
+
+  const code = context.cms.getLocale().code;
+  const locales = contentPermission.locales; // IMPORTANT: If we have a `contentPermission`, and `locales` key is NOT SET - it means the user has access to all locales.
+  // However, if the the `locales` IS SET - check that it contains the required locale.
+
+  if (Array.isArray(locales) && !locales.includes(code)) {
+    throw new _apiSecurity.NotAuthorizedError({
+      data: {
+        reason: `Not allowed to access content in "${code}."`
+      }
+    });
+  }
+
+  const permission = await context.security.getPermission(name);
+
+  if (!permission) {
+    throw new _apiSecurity.NotAuthorizedError({
+      data: {
+        reason: `Missing permission "${name}".`
+      }
+    });
+  }
+
+  if (!check) {
+    return permission;
+  }
+
+  if (check.rwd && !hasRwd(permission, check.rwd)) {
+    throw new _apiSecurity.NotAuthorizedError({
+      data: {
+        reason: `Not allowed to perform "${RWD[check.rwd]}" on "${name}".`
+      }
+    });
+  } // p = publish
+  // u = unpublish
+
+
+  if (check.pw && !hasPw(permission, check.pw)) {
+    throw new _apiSecurity.NotAuthorizedError({
+      data: {
+        reason: `Not allowed to perform "${PW[check.pw]}" on "${name}".`
+      }
+    });
+  }
+
+  return permission;
+};
+
+exports.checkPermissions = checkPermissions;

package/utils/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hasRwd","permission","rwd","includes","hasPw","pw","isCustom","Object","keys","length","PW","p","u","RWD","r","w","d","checkPermissions","context","name","check","contentPermission","security","getPermission","NotAuthorizedError","data","reason","code","cms","getLocale","locales","Array","isArray"],"sources":["permissions.ts"],"sourcesContent":["import { BaseCmsSecurityPermission, CmsContext, CmsEntryPermission } from \"~/types\";\nimport { NotAuthorizedError } from \"@webiny/api-security\";\n\nexport const hasRwd = (permission: BaseCmsSecurityPermission, rwd: string): boolean => {\n    if (typeof permission.rwd !== \"string\") {\n        return true;\n    }\n\n    return permission.rwd.includes(rwd);\n};\n\nexport const hasPw = (permission: CmsEntryPermission, pw: string): boolean => {\n    const isCustom = Object.keys(permission).length > 1; // \"name\" key is always present\n\n    if (!isCustom) {\n        // Means it's a \"full-access\" permission.\n        return true;\n    }\n\n    if (typeof permission.pw !== \"string\") {\n        return false;\n    }\n\n    return permission.pw.includes(pw);\n};\n\nconst PW: Record<string, string> = {\n    p: \"publish\",\n    u: \"unpublish\"\n};\n\nconst RWD: Record<string, string> = {\n    r: \"read\",\n    w: \"write\",\n    d: \"delete\"\n};\n\nexport const checkPermissions = async <\n    TPermission extends BaseCmsSecurityPermission = BaseCmsSecurityPermission\n>(\n    context: CmsContext,\n    name: string,\n    check?: { rwd?: string; pw?: string }\n): Promise<TPermission> => {\n    // Check if user is allowed to edit content in current language\n    const contentPermission = await context.security.getPermission(\"content.i18n\");\n\n    if (!contentPermission) {\n        throw new NotAuthorizedError({\n            data: {\n                reason: \"Missing access to content in any locale.\"\n            }\n        });\n    }\n\n    // We need to check this manually as CMS locale comes from the URL and not the default i18n app.\n    const code = context.cms.getLocale().code;\n\n    const locales: string[] = contentPermission.locales;\n\n    // IMPORTANT: If we have a `contentPermission`, and `locales` key is NOT SET - it means the user has access to all locales.\n    // However, if the the `locales` IS SET - check that it contains the required locale.\n    if (Array.isArray(locales) && !locales.includes(code)) {\n        throw new NotAuthorizedError({\n            data: {\n                reason: `Not allowed to access content in \"${code}.\"`\n            }\n        });\n    }\n\n    const permission = await context.security.getPermission<TPermission>(name);\n\n    if (!permission) {\n        throw new NotAuthorizedError({\n            data: {\n                reason: `Missing permission \"${name}\".`\n            }\n        });\n    }\n\n    if (!check) {\n        return permission;\n    }\n\n    if (check.rwd && !hasRwd(permission, check.rwd)) {\n        throw new NotAuthorizedError({\n            data: {\n                reason: `Not allowed to perform \"${RWD[check.rwd]}\" on \"${name}\".`\n            }\n        });\n    }\n\n    // p = publish\n    // u = unpublish\n    if (check.pw && !hasPw(permission, check.pw)) {\n        throw new NotAuthorizedError({\n            data: {\n                reason: `Not allowed to perform \"${PW[check.pw]}\" on \"${name}\".`\n            }\n        });\n    }\n\n    return permission;\n};\n"],"mappings":"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"}

package/utils/pluralizedTypeName.d.ts

@@ -0,0 +1 @@
+export declare const pluralizedTypeName: (typeName: string) => string;

package/{content/plugins/utils → utils}/pluralizedTypeName.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 
 Object.defineProperty(exports, "__esModule", {
   value: true

package/utils/pluralizedTypeName.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["pluralizedTypeName","typeName","length","pluralize"],"sources":["pluralizedTypeName.ts"],"sourcesContent":["import pluralize from \"pluralize\";\n\n// This will make it so if the content model name is a single capitalized letter\n// Ex. A, pluralizedTypeName will capitalize the name to As, instead of AS\nexport const pluralizedTypeName = (typeName: string): string => {\n    let pluralizedTypeName;\n    if (typeName.length === 1) {\n        pluralizedTypeName = `${typeName}s`;\n    } else {\n        pluralizedTypeName = pluralize(typeName);\n    }\n    return pluralizedTypeName;\n};\n"],"mappings":";;;;;;;;;AAAA;;AAEA;AACA;AACO,MAAMA,kBAAkB,GAAIC,QAAD,IAA8B;EAC5D,IAAID,kBAAJ;;EACA,IAAIC,QAAQ,CAACC,MAAT,KAAoB,CAAxB,EAA2B;IACvBF,kBAAkB,GAAI,GAAEC,QAAS,GAAjC;EACH,CAFD,MAEO;IACHD,kBAAkB,GAAG,IAAAG,kBAAA,EAAUF,QAAV,CAArB;EACH;;EACD,OAAOD,kBAAP;AACH,CARM"}

package/utils/renderFields.d.ts

@@ -0,0 +1,15 @@
+import { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types";
+interface RenderFieldsParams {
+    model: CmsModel;
+    type: ApiEndpoint;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
+interface RenderFields {
+    (params: RenderFieldsParams): CmsModelFieldDefinition[];
+}
+export declare const renderFields: RenderFields;
+interface RenderFieldParams extends RenderFieldsParams {
+    field: CmsModelField;
+}
+export declare const renderField: ({ model, type, field, fieldTypePlugins }: RenderFieldParams) => CmsModelFieldDefinition | null;
+export {};

package/{content/plugins/utils → utils}/renderFields.js

@@ -30,7 +30,7 @@ const renderField = ({
 
   if (!plugin) {
     // Let's not render the field if it does not exist in the field plugins.
-    return;
+    return null;
   }
 
   const defs = plugin[type].createTypeField({
@@ -39,7 +39,9 @@ const renderField = ({
     fieldTypePlugins
   });
 
-  if (typeof defs === "string") {
+  if (!defs) {
+    return null;
+  } else if (typeof defs === "string") {
     return {
       fields: defs
     };

package/utils/renderFields.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["renderFields","model","type","fieldTypePlugins","fields","map","field","renderField","filter","Boolean","plugin","defs","createTypeField"],"sources":["renderFields.ts"],"sourcesContent":["import {\n    ApiEndpoint,\n    CmsFieldTypePlugins,\n    CmsModel,\n    CmsModelField,\n    CmsModelFieldDefinition,\n    CmsModelFieldToGraphQLPlugin\n} from \"~/types\";\n\ninterface RenderFieldsParams {\n    model: CmsModel;\n    type: ApiEndpoint;\n    fieldTypePlugins: CmsFieldTypePlugins;\n}\ninterface RenderFields {\n    (params: RenderFieldsParams): CmsModelFieldDefinition[];\n}\n\nexport const renderFields: RenderFields = ({\n    model,\n    type,\n    fieldTypePlugins\n}): CmsModelFieldDefinition[] => {\n    return model.fields\n        .map(field => renderField({ model, type, field, fieldTypePlugins }))\n        .filter(Boolean) as CmsModelFieldDefinition[];\n};\n\ninterface RenderFieldParams extends RenderFieldsParams {\n    field: CmsModelField;\n}\n\nexport const renderField = ({\n    model,\n    type,\n    field,\n    fieldTypePlugins\n}: RenderFieldParams): CmsModelFieldDefinition | null => {\n    const plugin: CmsModelFieldToGraphQLPlugin = fieldTypePlugins[field.type];\n    if (!plugin) {\n        // Let's not render the field if it does not exist in the field plugins.\n        return null;\n    }\n    const defs = plugin[type].createTypeField({\n        model,\n        field,\n        fieldTypePlugins\n    });\n\n    if (!defs) {\n        return null;\n    } else if (typeof defs === \"string\") {\n        return {\n            fields: defs\n        };\n    }\n\n    return defs;\n};\n"],"mappings":";;;;;;;AAkBO,MAAMA,YAA0B,GAAG,CAAC;EACvCC,KADuC;EAEvCC,IAFuC;EAGvCC;AAHuC,CAAD,KAIT;EAC7B,OAAOF,KAAK,CAACG,MAAN,CACFC,GADE,CACEC,KAAK,IAAIC,WAAW,CAAC;IAAEN,KAAF;IAASC,IAAT;IAAeI,KAAf;IAAsBH;EAAtB,CAAD,CADtB,EAEFK,MAFE,CAEKC,OAFL,CAAP;AAGH,CARM;;;;AAcA,MAAMF,WAAW,GAAG,CAAC;EACxBN,KADwB;EAExBC,IAFwB;EAGxBI,KAHwB;EAIxBH;AAJwB,CAAD,KAK8B;EACrD,MAAMO,MAAoC,GAAGP,gBAAgB,CAACG,KAAK,CAACJ,IAAP,CAA7D;;EACA,IAAI,CAACQ,MAAL,EAAa;IACT;IACA,OAAO,IAAP;EACH;;EACD,MAAMC,IAAI,GAAGD,MAAM,CAACR,IAAD,CAAN,CAAaU,eAAb,CAA6B;IACtCX,KADsC;IAEtCK,KAFsC;IAGtCH;EAHsC,CAA7B,CAAb;;EAMA,IAAI,CAACQ,IAAL,EAAW;IACP,OAAO,IAAP;EACH,CAFD,MAEO,IAAI,OAAOA,IAAP,KAAgB,QAApB,EAA8B;IACjC,OAAO;MACHP,MAAM,EAAEO;IADL,CAAP;EAGH;;EAED,OAAOA,IAAP;AACH,CA1BM"}

package/utils/renderGetFilterFields.d.ts

@@ -0,0 +1,10 @@
+import { CmsFieldTypePlugins, CmsModel } from "../types";
+interface RenderGetFilterFieldsParams {
+    model: CmsModel;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
+interface RenderGetFilterFields {
+    (params: RenderGetFilterFieldsParams): string;
+}
+export declare const renderGetFilterFields: RenderGetFilterFields;
+export {};

package/{content/plugins/utils → utils}/renderGetFilterFields.js

@@ -1,38 +1,53 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.renderGetFilterFields = void 0;
 
-var _get = _interopRequireDefault(require("lodash/get"));
+const getCreateFilters = (plugins, fieldType) => {
+  if (!plugins[fieldType] || !plugins[fieldType].read.createGetFilters) {
+    return null;
+  }
+
+  return plugins[fieldType].read.createGetFilters;
+};
 
 const renderGetFilterFields = ({
   model,
   fieldTypePlugins
 }) => {
-  const fieldIds = model.fields.filter(f => {
+  const fieldIdList = model.fields.filter(field => {
     // Every time a client updates content model's fields, we check the type of each field. If a field plugin
     // for a particular "field.type" doesn't exist on the backend yet, we throw an error. But still, we also
     // want to be careful when accessing the field plugin here too. It is still possible to have a content model
     // that contains a field, for which we don't have a plugin registered on the backend. For example, user
     // could've just removed the plugin from the backend.
-    return (0, _get.default)(fieldTypePlugins, `${f.type}.isSearchable`);
+    if (!fieldTypePlugins[field.type]) {
+      return false;
+    }
+
+    return fieldTypePlugins[field.type].isSearchable;
   }).map(f => f.fieldId);
   const filters = ["id: ID", "entryId: String"];
 
-  for (let i = 0; i < fieldIds.length; i++) {
-    const field = model.fields.find(item => item.fieldId === fieldIds[i]);
-    const createGetFilters = (0, _get.default)(fieldTypePlugins, `${field.type}.read.createGetFilters`);
+  for (const fieldId of fieldIdList) {
+    const field = model.fields.find(item => item.fieldId === fieldId);
 
-    if (typeof createGetFilters === "function") {
-      filters.push(createGetFilters({
-        model,
-        field
-      }));
+    if (!field) {
+      continue;
     }
+
+    const createGetFilters = getCreateFilters(fieldTypePlugins, field.type);
+
+    if (typeof createGetFilters !== "function") {
+      continue;
+    }
+
+    filters.push(createGetFilters({
+      model,
+      field
+    }));
   }
 
   return filters.filter(Boolean).join("\n");

package/utils/renderGetFilterFields.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getCreateFilters","plugins","fieldType","read","createGetFilters","renderGetFilterFields","model","fieldTypePlugins","fieldIdList","fields","filter","field","type","isSearchable","map","f","fieldId","filters","find","item","push","Boolean","join"],"sources":["renderGetFilterFields.ts"],"sourcesContent":["import { CmsFieldTypePlugins, CmsModel, CmsModelFieldToGraphQLPlugin } from \"~/types\";\n\ninterface RenderGetFilterFieldsParams {\n    model: CmsModel;\n    fieldTypePlugins: CmsFieldTypePlugins;\n}\ninterface RenderGetFilterFields {\n    (params: RenderGetFilterFieldsParams): string;\n}\n\nconst getCreateFilters = (\n    plugins: CmsFieldTypePlugins,\n    fieldType: string\n): CmsModelFieldToGraphQLPlugin[\"read\"][\"createGetFilters\"] | null => {\n    if (!plugins[fieldType] || !plugins[fieldType].read.createGetFilters) {\n        return null;\n    }\n    return plugins[fieldType].read.createGetFilters;\n};\n\nexport const renderGetFilterFields: RenderGetFilterFields = ({ model, fieldTypePlugins }) => {\n    const fieldIdList = model.fields\n        .filter(field => {\n            // Every time a client updates content model's fields, we check the type of each field. If a field plugin\n            // for a particular \"field.type\" doesn't exist on the backend yet, we throw an error. But still, we also\n            // want to be careful when accessing the field plugin here too. It is still possible to have a content model\n            // that contains a field, for which we don't have a plugin registered on the backend. For example, user\n            // could've just removed the plugin from the backend.\n            if (!fieldTypePlugins[field.type]) {\n                return false;\n            }\n            return fieldTypePlugins[field.type].isSearchable;\n        })\n        .map(f => f.fieldId);\n\n    const filters: string[] = [\"id: ID\", \"entryId: String\"];\n\n    for (const fieldId of fieldIdList) {\n        const field = model.fields.find(item => item.fieldId === fieldId);\n        if (!field) {\n            continue;\n        }\n        const createGetFilters = getCreateFilters(fieldTypePlugins, field.type);\n        if (typeof createGetFilters !== \"function\") {\n            continue;\n        }\n        filters.push(createGetFilters({ model, field }));\n    }\n\n    return filters.filter(Boolean).join(\"\\n\");\n};\n"],"mappings":";;;;;;;AAUA,MAAMA,gBAAgB,GAAG,CACrBC,OADqB,EAErBC,SAFqB,KAG6C;EAClE,IAAI,CAACD,OAAO,CAACC,SAAD,CAAR,IAAuB,CAACD,OAAO,CAACC,SAAD,CAAP,CAAmBC,IAAnB,CAAwBC,gBAApD,EAAsE;IAClE,OAAO,IAAP;EACH;;EACD,OAAOH,OAAO,CAACC,SAAD,CAAP,CAAmBC,IAAnB,CAAwBC,gBAA/B;AACH,CARD;;AAUO,MAAMC,qBAA4C,GAAG,CAAC;EAAEC,KAAF;EAASC;AAAT,CAAD,KAAiC;EACzF,MAAMC,WAAW,GAAGF,KAAK,CAACG,MAAN,CACfC,MADe,CACRC,KAAK,IAAI;IACb;IACA;IACA;IACA;IACA;IACA,IAAI,CAACJ,gBAAgB,CAACI,KAAK,CAACC,IAAP,CAArB,EAAmC;MAC/B,OAAO,KAAP;IACH;;IACD,OAAOL,gBAAgB,CAACI,KAAK,CAACC,IAAP,CAAhB,CAA6BC,YAApC;EACH,CAXe,EAYfC,GAZe,CAYXC,CAAC,IAAIA,CAAC,CAACC,OAZI,CAApB;EAcA,MAAMC,OAAiB,GAAG,CAAC,QAAD,EAAW,iBAAX,CAA1B;;EAEA,KAAK,MAAMD,OAAX,IAAsBR,WAAtB,EAAmC;IAC/B,MAAMG,KAAK,GAAGL,KAAK,CAACG,MAAN,CAAaS,IAAb,CAAkBC,IAAI,IAAIA,IAAI,CAACH,OAAL,KAAiBA,OAA3C,CAAd;;IACA,IAAI,CAACL,KAAL,EAAY;MACR;IACH;;IACD,MAAMP,gBAAgB,GAAGJ,gBAAgB,CAACO,gBAAD,EAAmBI,KAAK,CAACC,IAAzB,CAAzC;;IACA,IAAI,OAAOR,gBAAP,KAA4B,UAAhC,EAA4C;MACxC;IACH;;IACDa,OAAO,CAACG,IAAR,CAAahB,gBAAgB,CAAC;MAAEE,KAAF;MAASK;IAAT,CAAD,CAA7B;EACH;;EAED,OAAOM,OAAO,CAACP,MAAR,CAAeW,OAAf,EAAwBC,IAAxB,CAA6B,IAA7B,CAAP;AACH,CA9BM"}

package/utils/renderInputFields.d.ts

@@ -0,0 +1,14 @@
+import { CmsFieldTypePlugins, CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types";
+interface RenderInputFieldsParams {
+    model: CmsModel;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
+interface RenderInputFieldParams extends RenderInputFieldsParams {
+    field: CmsModelField;
+}
+interface RenderInputFields {
+    (params: RenderInputFieldsParams): CmsModelFieldDefinition[];
+}
+export declare const renderInputFields: RenderInputFields;
+export declare const renderInputField: ({ model, field, fieldTypePlugins }: RenderInputFieldParams) => CmsModelFieldDefinition | null;
+export {};

package/{content/plugins/utils → utils}/renderInputFields.js

@@ -32,7 +32,7 @@ const renderInputField = ({
 
   if (!plugin) {
     // Let's not render the field if it does not exist in the field plugins.
-    return;
+    return null;
   }
 
   const def = plugin.manage.createInputField({

package/utils/renderInputFields.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["renderInputFields","model","fieldTypePlugins","fields","map","field","renderInputField","filter","Boolean","plugin","type","def","manage","createInputField"],"sources":["renderInputFields.ts"],"sourcesContent":["import {\n    CmsFieldTypePlugins,\n    CmsModel,\n    CmsModelField,\n    CmsModelFieldDefinition,\n    CmsModelFieldToGraphQLPlugin\n} from \"~/types\";\n\ninterface RenderInputFieldsParams {\n    model: CmsModel;\n    fieldTypePlugins: CmsFieldTypePlugins;\n}\ninterface RenderInputFieldParams extends RenderInputFieldsParams {\n    field: CmsModelField;\n}\ninterface RenderInputFields {\n    (params: RenderInputFieldsParams): CmsModelFieldDefinition[];\n}\n\nexport const renderInputFields: RenderInputFields = ({\n    model,\n    fieldTypePlugins\n}): CmsModelFieldDefinition[] => {\n    return model.fields\n        .map(field => renderInputField({ model, field, fieldTypePlugins }))\n        .filter(Boolean) as CmsModelFieldDefinition[];\n};\n\nexport const renderInputField = ({\n    model,\n    field,\n    fieldTypePlugins\n}: RenderInputFieldParams): CmsModelFieldDefinition | null => {\n    // Every time a client updates content model's fields, we check the type of each field. If a field plugin\n    // for a particular \"field.type\" doesn't exist on the backend yet, we throw an error. But still, we also\n    // want to be careful when accessing the field plugin here too. It is still possible to have a content model\n    // that contains a field, for which we don't have a plugin registered on the backend. For example, user\n    // could've just removed the plugin from the backend.\n    const plugin: CmsModelFieldToGraphQLPlugin = fieldTypePlugins[field.type];\n\n    if (!plugin) {\n        // Let's not render the field if it does not exist in the field plugins.\n        return null;\n    }\n\n    const def = plugin.manage.createInputField({\n        model,\n        field,\n        fieldTypePlugins\n    });\n    if (typeof def === \"string\") {\n        return {\n            fields: def\n        };\n    }\n\n    return def;\n};\n"],"mappings":";;;;;;;AAmBO,MAAMA,iBAAoC,GAAG,CAAC;EACjDC,KADiD;EAEjDC;AAFiD,CAAD,KAGnB;EAC7B,OAAOD,KAAK,CAACE,MAAN,CACFC,GADE,CACEC,KAAK,IAAIC,gBAAgB,CAAC;IAAEL,KAAF;IAASI,KAAT;IAAgBH;EAAhB,CAAD,CAD3B,EAEFK,MAFE,CAEKC,OAFL,CAAP;AAGH,CAPM;;;;AASA,MAAMF,gBAAgB,GAAG,CAAC;EAC7BL,KAD6B;EAE7BI,KAF6B;EAG7BH;AAH6B,CAAD,KAI8B;EAC1D;EACA;EACA;EACA;EACA;EACA,MAAMO,MAAoC,GAAGP,gBAAgB,CAACG,KAAK,CAACK,IAAP,CAA7D;;EAEA,IAAI,CAACD,MAAL,EAAa;IACT;IACA,OAAO,IAAP;EACH;;EAED,MAAME,GAAG,GAAGF,MAAM,CAACG,MAAP,CAAcC,gBAAd,CAA+B;IACvCZ,KADuC;IAEvCI,KAFuC;IAGvCH;EAHuC,CAA/B,CAAZ;;EAKA,IAAI,OAAOS,GAAP,KAAe,QAAnB,EAA6B;IACzB,OAAO;MACHR,MAAM,EAAEQ;IADL,CAAP;EAGH;;EAED,OAAOA,GAAP;AACH,CA7BM"}

package/utils/renderListFilterFields.d.ts

@@ -0,0 +1,11 @@
+import { ApiEndpoint, CmsFieldTypePlugins, CmsModel } from "../types";
+interface RenderListFilterFieldsParams {
+    model: CmsModel;
+    type: ApiEndpoint;
+    fieldTypePlugins: CmsFieldTypePlugins;
+}
+interface RenderListFilterFields {
+    (params: RenderListFilterFieldsParams): string;
+}
+export declare const renderListFilterFields: RenderListFilterFields;
+export {};

package/{content/plugins/utils → utils}/renderListFilterFields.js

@@ -1,36 +1,56 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.renderListFilterFields = void 0;
 
-var _get = _interopRequireDefault(require("lodash/get"));
+/**
+ * We cast as read type, because input and output of read and manage are same. This way we ease things.
+ * Internal stuff so it should be ok.
+ * TODO note that if changing read/manage types, change this as well.
+ */
+const getCreateListFilters = (plugins, fieldType, type) => {
+  if (!plugins[fieldType]) {
+    return null;
+  } else if (!plugins[fieldType][type]) {
+    return null;
+  }
+
+  return plugins[fieldType][type].createListFilters;
+};
 
-const renderListFilterFields = ({
-  model,
-  type,
-  fieldTypePlugins
-}) => {
+const renderListFilterFields = params => {
+  const {
+    model,
+    type,
+    fieldTypePlugins
+  } = params;
   const fields = [["id: ID", "id_not: ID", "id_in: [ID!]", "id_not_in: [ID!]", "entryId: String", "entryId_not: String", "entryId_in: [String!]", "entryId_not_in: [String!]", "createdOn: DateTime", "createdOn_gt: DateTime", "createdOn_gte: DateTime", "createdOn_lt: DateTime", "createdOn_lte: DateTime", "createdOn_between: [DateTime!]", "createdOn_not_between: [DateTime!]", "savedOn: DateTime", "savedOn_gt: DateTime", "savedOn_gte: DateTime", "savedOn_lt: DateTime", "savedOn_lte: DateTime", "savedOn_between: [DateTime!]", "savedOn_not_between: [DateTime!]", "createdBy: String", "createdBy_not: String", "createdBy_in: [String!]", "createdBy_not_in: [String!]", "ownedBy: String", "ownedBy_not: String", "ownedBy_in: [String!]", "ownedBy_not_in: [String!]"].join("\n")];
+  /**
+   * We can find different statuses only in the manage API endpoint.
+   */
 
-  for (let i = 0; i < model.fields.length; i++) {
-    const field = model.fields[i]; // Every time a client updates content model's fields, we check the type of each field. If a field plugin
+  if (type === "manage") {
+    fields.push(...["status: String", "status_not: String", "status_in: [String!]", "status_not_in: [String!]"]);
+  }
+
+  for (const field of model.fields) {
+    // Every time a client updates content model's fields, we check the type of each field. If a field plugin
     // for a particular "field.type" doesn't exist on the backend yet, we throw an error. But still, we also
     // want to be careful when accessing the field plugin here too. It is still possible to have a content model
     // that contains a field, for which we don't have a plugin registered on the backend. For example, user
     // could've just removed the plugin from the backend.
+    const createListFilters = getCreateListFilters(fieldTypePlugins, field.type, type);
 
-    const createListFilters = (0, _get.default)(fieldTypePlugins, `${field.type}.${type}.createListFilters`);
-
-    if (typeof createListFilters === "function") {
-      fields.push(createListFilters({
-        model,
-        field
-      }));
+    if (typeof createListFilters !== "function") {
+      continue;
     }
+
+    fields.push(createListFilters({
+      model,
+      field
+    }));
   }
 
   return fields.filter(Boolean).join("\n");