@webiny/api-headless-cms 0.0.0-unstable.bca7b3e350 → 0.0.0-unstable.c27f4d8a31

package/utils/getEntryImage.js

@@ -0,0 +1,17 @@
+export function getEntryImage(model, entry) {
+  if (!model.imageFieldId) {
+    return null;
+  }
+  const field = model.fields.find(f => f.fieldId === model.imageFieldId);
+  if (!field) {
+    return null;
+  }
+  const imageFieldId = field.fieldId;
+  const value = entry.values[imageFieldId];
+  if (!value || typeof value !== "string") {
+    return null;
+  }
+  return value;
+}
+
+//# sourceMappingURL=getEntryImage.js.map

package/utils/getEntryImage.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getEntryImage","model","entry","imageFieldId","field","fields","find","f","fieldId","value","values"],"sources":["getEntryImage.ts"],"sourcesContent":["import type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\n\nexport function getEntryImage<T extends CmsEntryValues = CmsEntryValues>(\n    model: Pick<CmsModel, \"imageFieldId\" | \"fields\">,\n    entry: Pick<CmsEntry<T>, \"values\">\n): string | null {\n    if (!model.imageFieldId) {\n        return null;\n    }\n    const field = model.fields.find(f => f.fieldId === model.imageFieldId);\n    if (!field) {\n        return null;\n    }\n    const imageFieldId = field.fieldId as keyof T;\n    const value = entry.values[imageFieldId];\n    if (!value || typeof value !== \"string\") {\n        return null;\n    }\n    return value;\n}\n"],"mappings":"AAEA,OAAO,SAASA,aAAaA,CACzBC,KAAgD,EAChDC,KAAkC,EACrB;EACb,IAAI,CAACD,KAAK,CAACE,YAAY,EAAE;IACrB,OAAO,IAAI;EACf;EACA,MAAMC,KAAK,GAAGH,KAAK,CAACI,MAAM,CAACC,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,KAAKP,KAAK,CAACE,YAAY,CAAC;EACtE,IAAI,CAACC,KAAK,EAAE;IACR,OAAO,IAAI;EACf;EACA,MAAMD,YAAY,GAAGC,KAAK,CAACI,OAAkB;EAC7C,MAAMC,KAAK,GAAGP,KAAK,CAACQ,MAAM,CAACP,YAAY,CAAC;EACxC,IAAI,CAACM,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE;IACrC,OAAO,IAAI;EACf;EACA,OAAOA,KAAK;AAChB","ignoreList":[]}

package/utils/getEntryTitle.d.ts

@@ -1,2 +1,2 @@
-import { CmsEntry, CmsModel } from "../types";
-export declare function getEntryTitle(model: CmsModel, entry: CmsEntry): string;
+import type { CmsEntry, CmsEntryValues, CmsModel } from "../types/index.js";
+export declare function getEntryTitle<T extends CmsEntryValues = CmsEntryValues>(model: Pick<CmsModel, "titleFieldId" | "fields">, entry: Pick<CmsEntry<T>, "id" | "values">): string;

package/utils/getEntryTitle.js

@@ -1,10 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getEntryTitle = getEntryTitle;
-function getEntryTitle(model, entry) {
+export function getEntryTitle(model, entry) {
   if (!model.titleFieldId) {
     return entry.id;
   }
@@ -14,7 +8,7 @@ function getEntryTitle(model, entry) {
   }
   const titleFieldId = field.fieldId;
   const titleValue = entry.values[titleFieldId];
-  if (!titleValue) {
+  if (!titleValue || typeof titleValue !== "string") {
     return entry.id;
   }
   const {
@@ -31,4 +25,6 @@ function getEntryTitle(model, entry) {
     }
   }
   return titleValue;
-}
+}
+
+//# sourceMappingURL=getEntryTitle.js.map

package/utils/getEntryTitle.js.map

@@ -1 +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,aAAa,CAACC,KAAe,EAAEC,KAAe,EAAU;EACpE,IAAI,CAACD,KAAK,CAACE,YAAY,EAAE;IACrB,OAAOD,KAAK,CAACE,EAAE;EACnB;EACA,MAAMC,KAAK,GAAGJ,KAAK,CAACK,MAAM,CAACC,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,KAAKR,KAAK,CAACE,YAAY,CAAC;EACtE,IAAI,CAACE,KAAK,EAAE;IACR,OAAOH,KAAK,CAACE,EAAE;EACnB;EACA,MAAMD,YAAY,GAAGE,KAAK,CAACI,OAAO;EAClC,MAAMC,UAAU,GAAGR,KAAK,CAACS,MAAM,CAACR,YAAY,CAAC;EAC7C,IAAI,CAACO,UAAU,EAAE;IACb,OAAOR,KAAK,CAACE,EAAE;EACnB;EAEA,MAAM;IAAEQ,OAAO,GAAG,KAAK;IAAED;EAAO,CAAC,GAAGN,KAAK,CAACQ,gBAAgB,IAAI,CAAC,CAAC;EAChE,IAAI,CAACD,OAAO,IAAI,CAACD,MAAM,IAAIG,KAAK,CAACC,OAAO,CAACJ,MAAM,CAAC,KAAK,KAAK,EAAE;IACxD,OAAOD,UAAU;EACrB;EACA,KAAK,MAAMM,KAAK,IAAIL,MAAM,EAAE;IACxB;IACA,IAAIK,KAAK,CAACA,KAAK,IAAIN,UAAU,EAAE;MAC3B,OAAOM,KAAK,CAACC,KAAK;IACtB;EACJ;EACA,OAAOP,UAAU;AACrB"}
+{"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 type { CmsEntry, CmsEntryValues, CmsModel } from \"~/types/index.js\";\n\nexport function getEntryTitle<T extends CmsEntryValues = CmsEntryValues>(\n    model: Pick<CmsModel, \"titleFieldId\" | \"fields\">,\n    entry: Pick<CmsEntry<T>, \"id\" | \"values\">\n): 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 as keyof T;\n    const titleValue = entry.values[titleFieldId];\n    if (!titleValue || typeof titleValue !== \"string\") {\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":"AAEA,OAAO,SAASA,aAAaA,CACzBC,KAAgD,EAChDC,KAAyC,EACnC;EACN,IAAI,CAACD,KAAK,CAACE,YAAY,EAAE;IACrB,OAAOD,KAAK,CAACE,EAAE;EACnB;EACA,MAAMC,KAAK,GAAGJ,KAAK,CAACK,MAAM,CAACC,IAAI,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,KAAKR,KAAK,CAACE,YAAY,CAAC;EACtE,IAAI,CAACE,KAAK,EAAE;IACR,OAAOH,KAAK,CAACE,EAAE;EACnB;EACA,MAAMD,YAAY,GAAGE,KAAK,CAACI,OAAkB;EAC7C,MAAMC,UAAU,GAAGR,KAAK,CAACS,MAAM,CAACR,YAAY,CAAC;EAC7C,IAAI,CAACO,UAAU,IAAI,OAAOA,UAAU,KAAK,QAAQ,EAAE;IAC/C,OAAOR,KAAK,CAACE,EAAE;EACnB;EAEA,MAAM;IAAEQ,OAAO,GAAG,KAAK;IAAED;EAAO,CAAC,GAAGN,KAAK,CAACQ,gBAAgB,IAAI,CAAC,CAAC;EAChE,IAAI,CAACD,OAAO,IAAI,CAACD,MAAM,IAAIG,KAAK,CAACC,OAAO,CAACJ,MAAM,CAAC,KAAK,KAAK,EAAE;IACxD,OAAOD,UAAU;EACrB;EACA,KAAK,MAAMM,KAAK,IAAIL,MAAM,EAAE;IACxB;IACA,IAAIK,KAAK,CAACA,KAAK,IAAIN,UAAU,EAAE;MAC3B,OAAOM,KAAK,CAACC,KAAK;IACtB;EACJ;EACA,OAAOP,UAAU;AACrB","ignoreList":[]}

package/utils/getSchemaFromFieldPlugins.d.ts

@@ -1,9 +1,20 @@
-import { CmsModel, CmsFieldTypePlugins, ApiEndpoint } from "../types";
-import { CmsGraphQLSchemaPlugin } from "../plugins";
+import type { ApiEndpoint, CmsContext, CmsFieldTypePlugins, CmsModel } from "../types/index.js";
+import type { ICmsGraphQLSchemaPlugin } from "../plugins/index.js";
+import type { IGraphQLSchemaPlugin } from "@webiny/handler-graphql";
+import type { GraphQLSchemaDefinition } from "@webiny/handler-graphql/types.js";
+interface CreatePluginCallableParams {
+    schema: GraphQLSchemaDefinition<CmsContext>;
+    type: "manage" | "preview" | "read";
+    fieldType: string;
+}
+interface CreatePluginCallable {
+    (params: CreatePluginCallableParams): IGraphQLSchemaPlugin<CmsContext>;
+}
 interface Params {
     models: CmsModel[];
     fieldTypePlugins: CmsFieldTypePlugins;
     type: ApiEndpoint;
+    createPlugin?: CreatePluginCallable;
 }
-export declare const createGraphQLSchemaPluginFromFieldPlugins: (params: Params) => CmsGraphQLSchemaPlugin<import("../types").CmsContext>[];
+export declare const createGraphQLSchemaPluginFromFieldPlugins: (params: Params) => ICmsGraphQLSchemaPlugin[];
 export {};

package/utils/getSchemaFromFieldPlugins.js

@@ -1,28 +1,33 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createGraphQLSchemaPluginFromFieldPlugins = void 0;
-var _plugins = require("../plugins");
+import { createCmsGraphQLSchemaPlugin } from "../plugins/index.js";
 const TYPE_MAP = {
   preview: "read",
   read: "read",
   manage: "manage"
 };
-const createGraphQLSchemaPluginFromFieldPlugins = params => {
+const defaultCreatePlugin = ({
+  schema,
+  type,
+  fieldType
+}) => {
+  const plugin = createCmsGraphQLSchemaPlugin(schema);
+  plugin.name = `headless-cms.graphql.schema.${type}.field.${fieldType}`;
+  return plugin;
+};
+export const createGraphQLSchemaPluginFromFieldPlugins = params => {
   const {
     models,
     fieldTypePlugins,
-    type
+    type,
+    createPlugin = defaultCreatePlugin
   } = params;
+  const apiType = TYPE_MAP[type];
   const plugins = [];
   for (const key in fieldTypePlugins) {
     const fieldTypePlugin = fieldTypePlugins[key];
-    if (!TYPE_MAP[type] || !fieldTypePlugin[TYPE_MAP[type]]) {
+    if (!apiType || !fieldTypePlugin[apiType]) {
       continue;
     }
-    const createSchema = fieldTypePlugin[TYPE_MAP[type]].createSchema;
+    const createSchema = fieldTypePlugin[apiType].createSchema;
     // Render gql types generated by field type plugins
     if (!createSchema) {
       continue;
@@ -30,10 +35,17 @@ const createGraphQLSchemaPluginFromFieldPlugins = params => {
     const schema = createSchema({
       models
     });
-    const plugin = new _plugins.CmsGraphQLSchemaPlugin(schema);
-    plugin.name = `headless-cms.graphql.schema.${type}.field.${fieldTypePlugin.fieldType}`;
+
+    // const plugin = createCmsGraphQLSchemaPlugin(schema);
+    // plugin.name = `headless-cms.graphql.schema.${type}.field.${fieldTypePlugin.fieldType}`;
+    const plugin = createPlugin({
+      schema,
+      type,
+      fieldType: fieldTypePlugin.fieldType
+    });
     plugins.push(plugin);
   }
   return plugins;
 };
-exports.createGraphQLSchemaPluginFromFieldPlugins = createGraphQLSchemaPluginFromFieldPlugins;
+
+//# sourceMappingURL=getSchemaFromFieldPlugins.js.map

package/utils/getSchemaFromFieldPlugins.js.map

@@ -1 +1 @@
-{"version":3,"names":["TYPE_MAP","preview","read","manage","createGraphQLSchemaPluginFromFieldPlugins","params","models","fieldTypePlugins","type","plugins","key","fieldTypePlugin","createSchema","schema","plugin","CmsGraphQLSchemaPlugin","name","fieldType","push"],"sources":["getSchemaFromFieldPlugins.ts"],"sourcesContent":["import { CmsModel, CmsFieldTypePlugins, ApiEndpoint } from \"~/types\";\nimport { CmsGraphQLSchemaPlugin } from \"~/plugins\";\n\nconst TYPE_MAP: Record<string, \"manage\" | \"read\"> = {\n    preview: \"read\",\n    read: \"read\",\n    manage: \"manage\"\n};\n\ninterface Params {\n    models: CmsModel[];\n    fieldTypePlugins: CmsFieldTypePlugins;\n    type: ApiEndpoint;\n}\nexport const createGraphQLSchemaPluginFromFieldPlugins = (params: Params) => {\n    const { models, fieldTypePlugins, type } = params;\n\n    const plugins: CmsGraphQLSchemaPlugin[] = [];\n    for (const key in fieldTypePlugins) {\n        const fieldTypePlugin = fieldTypePlugins[key];\n        if (!TYPE_MAP[type] || !fieldTypePlugin[TYPE_MAP[type]]) {\n            continue;\n        }\n        const createSchema = fieldTypePlugin[TYPE_MAP[type]].createSchema;\n        // Render gql types generated by field type plugins\n        if (!createSchema) {\n            continue;\n        }\n        const schema = createSchema({ models });\n\n        const plugin = new CmsGraphQLSchemaPlugin(schema);\n        plugin.name = `headless-cms.graphql.schema.${type}.field.${fieldTypePlugin.fieldType}`;\n        plugins.push(plugin);\n    }\n    return plugins;\n};\n"],"mappings":";;;;;;AACA;AAEA,MAAMA,QAA2C,GAAG;EAChDC,OAAO,EAAE,MAAM;EACfC,IAAI,EAAE,MAAM;EACZC,MAAM,EAAE;AACZ,CAAC;AAOM,MAAMC,yCAAyC,GAAIC,MAAc,IAAK;EACzE,MAAM;IAAEC,MAAM;IAAEC,gBAAgB;IAAEC;EAAK,CAAC,GAAGH,MAAM;EAEjD,MAAMI,OAAiC,GAAG,EAAE;EAC5C,KAAK,MAAMC,GAAG,IAAIH,gBAAgB,EAAE;IAChC,MAAMI,eAAe,GAAGJ,gBAAgB,CAACG,GAAG,CAAC;IAC7C,IAAI,CAACV,QAAQ,CAACQ,IAAI,CAAC,IAAI,CAACG,eAAe,CAACX,QAAQ,CAACQ,IAAI,CAAC,CAAC,EAAE;MACrD;IACJ;IACA,MAAMI,YAAY,GAAGD,eAAe,CAACX,QAAQ,CAACQ,IAAI,CAAC,CAAC,CAACI,YAAY;IACjE;IACA,IAAI,CAACA,YAAY,EAAE;MACf;IACJ;IACA,MAAMC,MAAM,GAAGD,YAAY,CAAC;MAAEN;IAAO,CAAC,CAAC;IAEvC,MAAMQ,MAAM,GAAG,IAAIC,+BAAsB,CAACF,MAAM,CAAC;IACjDC,MAAM,CAACE,IAAI,GAAI,+BAA8BR,IAAK,UAASG,eAAe,CAACM,SAAU,EAAC;IACtFR,OAAO,CAACS,IAAI,CAACJ,MAAM,CAAC;EACxB;EACA,OAAOL,OAAO;AAClB,CAAC;AAAC"}
+{"version":3,"names":["createCmsGraphQLSchemaPlugin","TYPE_MAP","preview","read","manage","defaultCreatePlugin","schema","type","fieldType","plugin","name","createGraphQLSchemaPluginFromFieldPlugins","params","models","fieldTypePlugins","createPlugin","apiType","plugins","key","fieldTypePlugin","createSchema","push"],"sources":["getSchemaFromFieldPlugins.ts"],"sourcesContent":["import type { ApiEndpoint, CmsContext, CmsFieldTypePlugins, CmsModel } from \"~/types/index.js\";\nimport type { ICmsGraphQLSchemaPlugin } from \"~/plugins/index.js\";\nimport { createCmsGraphQLSchemaPlugin } from \"~/plugins/index.js\";\nimport type { IGraphQLSchemaPlugin } from \"@webiny/handler-graphql\";\nimport type { GraphQLSchemaDefinition } from \"@webiny/handler-graphql/types.js\";\n\nconst TYPE_MAP: Record<string, \"manage\" | \"read\"> = {\n    preview: \"read\",\n    read: \"read\",\n    manage: \"manage\"\n};\n\ninterface CreatePluginCallableParams {\n    schema: GraphQLSchemaDefinition<CmsContext>;\n    type: \"manage\" | \"preview\" | \"read\";\n    fieldType: string;\n}\n\ninterface CreatePluginCallable {\n    (params: CreatePluginCallableParams): IGraphQLSchemaPlugin<CmsContext>;\n}\n\nconst defaultCreatePlugin: CreatePluginCallable = ({ schema, type, fieldType }) => {\n    const plugin = createCmsGraphQLSchemaPlugin(schema);\n    plugin.name = `headless-cms.graphql.schema.${type}.field.${fieldType}`;\n    return plugin;\n};\n\ninterface Params {\n    models: CmsModel[];\n    fieldTypePlugins: CmsFieldTypePlugins;\n    type: ApiEndpoint;\n    createPlugin?: CreatePluginCallable;\n}\nexport const createGraphQLSchemaPluginFromFieldPlugins = (params: Params) => {\n    const { models, fieldTypePlugins, type, createPlugin = defaultCreatePlugin } = params;\n\n    const apiType = TYPE_MAP[type];\n\n    const plugins: ICmsGraphQLSchemaPlugin[] = [];\n    for (const key in fieldTypePlugins) {\n        const fieldTypePlugin = fieldTypePlugins[key];\n        if (!apiType || !fieldTypePlugin[apiType]) {\n            continue;\n        }\n        const createSchema = fieldTypePlugin[apiType].createSchema;\n        // Render gql types generated by field type plugins\n        if (!createSchema) {\n            continue;\n        }\n        const schema = createSchema({ models });\n\n        // const plugin = createCmsGraphQLSchemaPlugin(schema);\n        // plugin.name = `headless-cms.graphql.schema.${type}.field.${fieldTypePlugin.fieldType}`;\n        const plugin = createPlugin({\n            schema,\n            type,\n            fieldType: fieldTypePlugin.fieldType\n        });\n        plugins.push(plugin);\n    }\n    return plugins;\n};\n"],"mappings":"AAEA,SAASA,4BAA4B;AAIrC,MAAMC,QAA2C,GAAG;EAChDC,OAAO,EAAE,MAAM;EACfC,IAAI,EAAE,MAAM;EACZC,MAAM,EAAE;AACZ,CAAC;AAYD,MAAMC,mBAAyC,GAAGA,CAAC;EAAEC,MAAM;EAAEC,IAAI;EAAEC;AAAU,CAAC,KAAK;EAC/E,MAAMC,MAAM,GAAGT,4BAA4B,CAACM,MAAM,CAAC;EACnDG,MAAM,CAACC,IAAI,GAAG,+BAA+BH,IAAI,UAAUC,SAAS,EAAE;EACtE,OAAOC,MAAM;AACjB,CAAC;AAQD,OAAO,MAAME,yCAAyC,GAAIC,MAAc,IAAK;EACzE,MAAM;IAAEC,MAAM;IAAEC,gBAAgB;IAAEP,IAAI;IAAEQ,YAAY,GAAGV;EAAoB,CAAC,GAAGO,MAAM;EAErF,MAAMI,OAAO,GAAGf,QAAQ,CAACM,IAAI,CAAC;EAE9B,MAAMU,OAAkC,GAAG,EAAE;EAC7C,KAAK,MAAMC,GAAG,IAAIJ,gBAAgB,EAAE;IAChC,MAAMK,eAAe,GAAGL,gBAAgB,CAACI,GAAG,CAAC;IAC7C,IAAI,CAACF,OAAO,IAAI,CAACG,eAAe,CAACH,OAAO,CAAC,EAAE;MACvC;IACJ;IACA,MAAMI,YAAY,GAAGD,eAAe,CAACH,OAAO,CAAC,CAACI,YAAY;IAC1D;IACA,IAAI,CAACA,YAAY,EAAE;MACf;IACJ;IACA,MAAMd,MAAM,GAAGc,YAAY,CAAC;MAAEP;IAAO,CAAC,CAAC;;IAEvC;IACA;IACA,MAAMJ,MAAM,GAAGM,YAAY,CAAC;MACxBT,MAAM;MACNC,IAAI;MACJC,SAAS,EAAEW,eAAe,CAACX;IAC/B,CAAC,CAAC;IACFS,OAAO,CAACI,IAAI,CAACZ,MAAM,CAAC;EACxB;EACA,OAAOQ,OAAO;AAClB,CAAC","ignoreList":[]}

package/utils/identity.d.ts

@@ -0,0 +1,7 @@
+import type { SecurityIdentity } from "@webiny/api-core/types/security.js";
+import type { CmsIdentity } from "../types/index.js";
+type IdentityLike = Pick<CmsIdentity, "id" | "displayName" | "type">;
+export declare function getIdentity(input: SecurityIdentity | CmsIdentity): IdentityLike;
+export declare function getIdentity(input: SecurityIdentity | CmsIdentity | null | undefined, defaultValue: SecurityIdentity | CmsIdentity): IdentityLike;
+export declare function getIdentity(input: SecurityIdentity | CmsIdentity | null | undefined, defaultValue?: SecurityIdentity | CmsIdentity | null): IdentityLike | null;
+export {};

package/utils/identity.js

@@ -0,0 +1,19 @@
+// input guaranteed → never null
+
+// input nullable, default provided → never null
+
+// input nullable, default nullable/omitted → may return null
+
+export function getIdentity(input, defaultValue) {
+  const identity = input?.id && input?.displayName && input?.type ? input : defaultValue;
+  if (!identity) {
+    return null;
+  }
+  return {
+    id: identity.id,
+    displayName: identity.displayName,
+    type: identity.type
+  };
+}
+
+//# sourceMappingURL=identity.js.map

package/utils/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getIdentity","input","defaultValue","identity","id","displayName","type"],"sources":["identity.ts"],"sourcesContent":["import type { SecurityIdentity } from \"@webiny/api-core/types/security.js\";\nimport type { CmsIdentity } from \"~/types/index.js\";\n\ntype IdentityLike = Pick<CmsIdentity, \"id\" | \"displayName\" | \"type\">;\n\n// input guaranteed → never null\nexport function getIdentity(input: SecurityIdentity | CmsIdentity): IdentityLike;\n\n// input nullable, default provided → never null\nexport function getIdentity(\n    input: SecurityIdentity | CmsIdentity | null | undefined,\n    defaultValue: SecurityIdentity | CmsIdentity\n): IdentityLike;\n\n// input nullable, default nullable/omitted → may return null\nexport function getIdentity(\n    input: SecurityIdentity | CmsIdentity | null | undefined,\n    defaultValue?: SecurityIdentity | CmsIdentity | null\n): IdentityLike | null;\n\nexport function getIdentity(\n    input: SecurityIdentity | CmsIdentity | null | undefined,\n    defaultValue?: SecurityIdentity | CmsIdentity | null\n): IdentityLike | null {\n    const identity = input?.id && input?.displayName && input?.type ? input : defaultValue;\n\n    if (!identity) {\n        return null;\n    }\n\n    return {\n        id: identity.id,\n        displayName: identity.displayName,\n        type: identity.type\n    };\n}\n"],"mappings":"AAKA;;AAGA;;AAMA;;AAMA,OAAO,SAASA,WAAWA,CACvBC,KAAwD,EACxDC,YAAoD,EACjC;EACnB,MAAMC,QAAQ,GAAGF,KAAK,EAAEG,EAAE,IAAIH,KAAK,EAAEI,WAAW,IAAIJ,KAAK,EAAEK,IAAI,GAAGL,KAAK,GAAGC,YAAY;EAEtF,IAAI,CAACC,QAAQ,EAAE;IACX,OAAO,IAAI;EACf;EAEA,OAAO;IACHC,EAAE,EAAED,QAAQ,CAACC,EAAE;IACfC,WAAW,EAAEF,QAAQ,CAACE,WAAW;IACjCC,IAAI,EAAEH,QAAQ,CAACG;EACnB,CAAC;AACL","ignoreList":[]}

package/utils/incrementEntryIdVersion.d.ts

@@ -0,0 +1,5 @@
+export declare const incrementEntryIdVersion: (id: string) => {
+    entryId: string;
+    version: number;
+    id: string;
+};

package/utils/incrementEntryIdVersion.js

@@ -0,0 +1,23 @@
+import { createIdentifier, parseIdentifier } from "@webiny/utils";
+import WebinyError from "@webiny/error";
+export const incrementEntryIdVersion = id => {
+  const {
+    id: entryId,
+    version
+  } = parseIdentifier(id);
+  if (!version) {
+    throw new WebinyError("Cannot increase version on the ID without the version part.", "WRONG_ID", {
+      id
+    });
+  }
+  return {
+    entryId,
+    version: version + 1,
+    id: createIdentifier({
+      id: entryId,
+      version: version + 1
+    })
+  };
+};
+
+//# sourceMappingURL=incrementEntryIdVersion.js.map

package/utils/incrementEntryIdVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createIdentifier","parseIdentifier","WebinyError","incrementEntryIdVersion","id","entryId","version"],"sources":["incrementEntryIdVersion.ts"],"sourcesContent":["import { createIdentifier, parseIdentifier } from \"@webiny/utils\";\nimport WebinyError from \"@webiny/error\";\n\nexport const incrementEntryIdVersion = (id: string) => {\n    const { id: entryId, version } = parseIdentifier(id);\n    if (!version) {\n        throw new WebinyError(\n            \"Cannot increase version on the ID without the version part.\",\n            \"WRONG_ID\",\n            {\n                id\n            }\n        );\n    }\n    return {\n        entryId,\n        version: version + 1,\n        id: createIdentifier({\n            id: entryId,\n            version: version + 1\n        })\n    };\n};\n"],"mappings":"AAAA,SAASA,gBAAgB,EAAEC,eAAe,QAAQ,eAAe;AACjE,OAAOC,WAAW,MAAM,eAAe;AAEvC,OAAO,MAAMC,uBAAuB,GAAIC,EAAU,IAAK;EACnD,MAAM;IAAEA,EAAE,EAAEC,OAAO;IAAEC;EAAQ,CAAC,GAAGL,eAAe,CAACG,EAAE,CAAC;EACpD,IAAI,CAACE,OAAO,EAAE;IACV,MAAM,IAAIJ,WAAW,CACjB,6DAA6D,EAC7D,UAAU,EACV;MACIE;IACJ,CACJ,CAAC;EACL;EACA,OAAO;IACHC,OAAO;IACPC,OAAO,EAAEA,OAAO,GAAG,CAAC;IACpBF,EAAE,EAAEJ,gBAAgB,CAAC;MACjBI,EAAE,EAAEC,OAAO;MACXC,OAAO,EAAEA,OAAO,GAAG;IACvB,CAAC;EACL,CAAC;AACL,CAAC","ignoreList":[]}

package/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./caching/index.js";
+export * from "./modelFieldTraverser/index.js";

package/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./caching/index.js";
+export * from "./modelFieldTraverser/index.js";
+
+//# sourceMappingURL=index.js.map

package/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./caching/index.js\";\nexport * from \"./modelFieldTraverser/index.js\";\n"],"mappings":"AAAA;AACA","ignoreList":[]}

package/utils/isHeadlessCmsReady.d.ts

@@ -0,0 +1,5 @@
+import type { CmsContext } from "../types/index.js";
+/**
+ * TODO: Legacy function - review and remove!
+ */
+export declare const isHeadlessCmsReady: ({ tenancy }: CmsContext) => Promise<boolean>;

package/utils/isHeadlessCmsReady.js

@@ -0,0 +1,17 @@
+/**
+ * TODO: Legacy function - review and remove!
+ */
+export const isHeadlessCmsReady = async ({
+  tenancy
+}) => {
+  /**
+   * In case of a fresh webiny project "tenant" won't be there until the installation is completed.
+   */
+  const tenant = tenancy.getCurrentTenant();
+  if (!tenant) {
+    return false;
+  }
+  return true;
+};
+
+//# sourceMappingURL=isHeadlessCmsReady.js.map

package/utils/isHeadlessCmsReady.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isHeadlessCmsReady","tenancy","tenant","getCurrentTenant"],"sources":["isHeadlessCmsReady.ts"],"sourcesContent":["import type { CmsContext } from \"~/types/index.js\";\n\n/**\n * TODO: Legacy function - review and remove!\n */\nexport const isHeadlessCmsReady = async ({ tenancy }: CmsContext): Promise<boolean> => {\n    /**\n     * In case of a fresh webiny project \"tenant\" won't be there until the installation is completed.\n     */\n    const tenant = tenancy.getCurrentTenant();\n    if (!tenant) {\n        return false;\n    }\n\n    return true;\n};\n"],"mappings":"AAEA;AACA;AACA;AACA,OAAO,MAAMA,kBAAkB,GAAG,MAAAA,CAAO;EAAEC;AAAoB,CAAC,KAAuB;EACnF;AACJ;AACA;EACI,MAAMC,MAAM,GAAGD,OAAO,CAACE,gBAAgB,CAAC,CAAC;EACzC,IAAI,CAACD,MAAM,EAAE;IACT,OAAO,KAAK;EAChB;EAEA,OAAO,IAAI;AACf,CAAC","ignoreList":[]}

package/utils/modelFieldTraverser/ModelFieldTraverser.d.ts

@@ -0,0 +1,16 @@
+import type { CmsModelAst, CmsModelField } from "../../types/index.js";
+export interface IModelFieldTraverserTraverseOnFieldCallableParams {
+    field: CmsModelField;
+    path: string[];
+}
+export interface IModelFieldTraverserTraverseOnFieldCallable {
+    (params: IModelFieldTraverserTraverseOnFieldCallableParams): void;
+}
+export interface IModelFieldTraverser {
+    traverse(modelAst: CmsModelAst, onField: IModelFieldTraverserTraverseOnFieldCallable): void;
+}
+export declare class ModelFieldTraverser implements IModelFieldTraverser {
+    traverse(modelAst: CmsModelAst, onField: IModelFieldTraverserTraverseOnFieldCallable): void;
+    private execute;
+    private getFieldFromNode;
+}

package/utils/modelFieldTraverser/ModelFieldTraverser.js

@@ -0,0 +1,34 @@
+const nodeHasChildren = node => {
+  return node.children.length > 0;
+};
+export class ModelFieldTraverser {
+  traverse(modelAst, onField) {
+    this.execute(modelAst, [], onField);
+  }
+  execute(root, path, onField) {
+    for (const node of root.children) {
+      const field = this.getFieldFromNode({
+        node,
+        parent: root
+      });
+      onField({
+        field,
+        path: [...path, field.fieldId]
+      });
+      if (nodeHasChildren(node)) {
+        this.execute(node, [...path, field.fieldId], onField);
+      }
+    }
+  }
+  getFieldFromNode({
+    node,
+    parent
+  }) {
+    if (node.type === "collection") {
+      return parent.field;
+    }
+    return node.field;
+  }
+}
+
+//# sourceMappingURL=ModelFieldTraverser.js.map

package/utils/modelFieldTraverser/ModelFieldTraverser.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["nodeHasChildren","node","children","length","ModelFieldTraverser","traverse","modelAst","onField","execute","root","path","field","getFieldFromNode","parent","fieldId","type"],"sources":["ModelFieldTraverser.ts"],"sourcesContent":["import type {\n    CmsModelAst,\n    CmsModelField,\n    CmsModelFieldAstNode,\n    CmsModelFieldAstNodeField\n} from \"~/types/index.js\";\n\nconst nodeHasChildren = (node: CmsModelFieldAstNode) => {\n    return node.children.length > 0;\n};\n\ntype IParentNode = CmsModelAst | CmsModelFieldAstNode | null;\n\ninterface IVisitorContext {\n    node: CmsModelFieldAstNode;\n    parent: IParentNode;\n}\n\nexport interface IModelFieldTraverserTraverseOnFieldCallableParams {\n    field: CmsModelField;\n    path: string[];\n}\n\nexport interface IModelFieldTraverserTraverseOnFieldCallable {\n    (params: IModelFieldTraverserTraverseOnFieldCallableParams): void;\n}\n\nexport interface IModelFieldTraverser {\n    traverse(modelAst: CmsModelAst, onField: IModelFieldTraverserTraverseOnFieldCallable): void;\n}\n\nexport class ModelFieldTraverser implements IModelFieldTraverser {\n    public traverse(modelAst: CmsModelAst, onField: IModelFieldTraverserTraverseOnFieldCallable) {\n        this.execute(modelAst, [], onField);\n    }\n\n    private execute(\n        root: CmsModelAst | CmsModelFieldAstNode,\n        path: string[],\n        onField: IModelFieldTraverserTraverseOnFieldCallable\n    ) {\n        for (const node of root.children) {\n            const field = this.getFieldFromNode({ node, parent: root });\n            onField({\n                field,\n                path: [...path, field.fieldId]\n            });\n\n            if (nodeHasChildren(node)) {\n                this.execute(node, [...path, field.fieldId], onField);\n            }\n        }\n    }\n\n    private getFieldFromNode({ node, parent }: IVisitorContext) {\n        if (node.type === \"collection\") {\n            return (parent as CmsModelFieldAstNodeField).field;\n        }\n\n        return (node as CmsModelFieldAstNodeField).field;\n    }\n}\n"],"mappings":"AAOA,MAAMA,eAAe,GAAIC,IAA0B,IAAK;EACpD,OAAOA,IAAI,CAACC,QAAQ,CAACC,MAAM,GAAG,CAAC;AACnC,CAAC;AAsBD,OAAO,MAAMC,mBAAmB,CAAiC;EACtDC,QAAQA,CAACC,QAAqB,EAAEC,OAAoD,EAAE;IACzF,IAAI,CAACC,OAAO,CAACF,QAAQ,EAAE,EAAE,EAAEC,OAAO,CAAC;EACvC;EAEQC,OAAOA,CACXC,IAAwC,EACxCC,IAAc,EACdH,OAAoD,EACtD;IACE,KAAK,MAAMN,IAAI,IAAIQ,IAAI,CAACP,QAAQ,EAAE;MAC9B,MAAMS,KAAK,GAAG,IAAI,CAACC,gBAAgB,CAAC;QAAEX,IAAI;QAAEY,MAAM,EAAEJ;MAAK,CAAC,CAAC;MAC3DF,OAAO,CAAC;QACJI,KAAK;QACLD,IAAI,EAAE,CAAC,GAAGA,IAAI,EAAEC,KAAK,CAACG,OAAO;MACjC,CAAC,CAAC;MAEF,IAAId,eAAe,CAACC,IAAI,CAAC,EAAE;QACvB,IAAI,CAACO,OAAO,CAACP,IAAI,EAAE,CAAC,GAAGS,IAAI,EAAEC,KAAK,CAACG,OAAO,CAAC,EAAEP,OAAO,CAAC;MACzD;IACJ;EACJ;EAEQK,gBAAgBA,CAAC;IAAEX,IAAI;IAAEY;EAAwB,CAAC,EAAE;IACxD,IAAIZ,IAAI,CAACc,IAAI,KAAK,YAAY,EAAE;MAC5B,OAAQF,MAAM,CAA+BF,KAAK;IACtD;IAEA,OAAQV,IAAI,CAA+BU,KAAK;EACpD;AACJ","ignoreList":[]}

package/utils/modelFieldTraverser/index.d.ts

@@ -0,0 +1 @@
+export * from "./ModelFieldTraverser.js";

package/utils/modelFieldTraverser/index.js

@@ -0,0 +1,3 @@
+export * from "./ModelFieldTraverser.js";
+
+//# sourceMappingURL=index.js.map

package/utils/modelFieldTraverser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./ModelFieldTraverser.js\";\n"],"mappings":"AAAA","ignoreList":[]}

package/utils/renderFields.d.ts

@@ -1,6 +1,8 @@
-import { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types";
+import type { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types/index.js";
 interface RenderFieldsParams {
+    models: CmsModel[];
     model: CmsModel;
+    fields: CmsModelField[];
     type: ApiEndpoint;
     fieldTypePlugins: CmsFieldTypePlugins;
 }
@@ -8,8 +10,8 @@ interface RenderFields {
     (params: RenderFieldsParams): CmsModelFieldDefinition[];
 }
 export declare const renderFields: RenderFields;
-interface RenderFieldParams extends RenderFieldsParams {
+interface RenderFieldParams extends Omit<RenderFieldsParams, "fields"> {
     field: CmsModelField;
 }
-export declare const renderField: ({ model, type, field, fieldTypePlugins }: RenderFieldParams) => CmsModelFieldDefinition | null;
+export declare const renderField: ({ models, model, type, field, fieldTypePlugins }: RenderFieldParams) => CmsModelFieldDefinition | null;
 export {};

package/utils/renderFields.js

@@ -1,35 +1,38 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.renderFields = exports.renderField = void 0;
-var _getBaseFieldType = require("./getBaseFieldType");
-const renderFields = ({
+import { getBaseFieldType } from "./getBaseFieldType.js";
+export const renderFields = ({
+  models,
   model,
+  fields,
   type,
   fieldTypePlugins
 }) => {
-  return model.fields.map(field => renderField({
+  return fields.map(field => renderField({
+    models,
     model,
     type,
     field,
     fieldTypePlugins
   })).filter(Boolean);
 };
-exports.renderFields = renderFields;
-const renderField = ({
+export const renderField = ({
+  models,
   model,
   type,
   field,
   fieldTypePlugins
 }) => {
-  const plugin = fieldTypePlugins[(0, _getBaseFieldType.getBaseFieldType)(field)];
+  const plugin = fieldTypePlugins[getBaseFieldType(field)];
   if (!plugin) {
     // Let's not render the field if it does not exist in the field plugins.
     return null;
+  } else if (!plugin[type]) {
+    throw new Error(`Missing "${type}" plugin for field type "${field.type}".`);
   }
-  const defs = plugin[type].createTypeField({
+  const {
+    createTypeField
+  } = plugin[type];
+  const defs = createTypeField({
+    models,
     model,
     field,
     fieldTypePlugins
@@ -43,4 +46,5 @@ const renderField = ({
   }
   return defs;
 };
-exports.renderField = renderField;
+
+//# sourceMappingURL=renderFields.js.map

package/utils/renderFields.js.map

@@ -1 +1 @@
-{"version":3,"names":["renderFields","model","type","fieldTypePlugins","fields","map","field","renderField","filter","Boolean","plugin","getBaseFieldType","defs","createTypeField"],"sources":["renderFields.ts"],"sourcesContent":["import {\n    ApiEndpoint,\n    CmsFieldTypePlugins,\n    CmsModel,\n    CmsModelField,\n    CmsModelFieldDefinition,\n    CmsModelFieldToGraphQLPlugin\n} from \"~/types\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType\";\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[getBaseFieldType(field)];\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":";;;;;;AAQA;AAWO,MAAMA,YAA0B,GAAG,CAAC;EACvCC,KAAK;EACLC,IAAI;EACJC;AACJ,CAAC,KAAgC;EAC7B,OAAOF,KAAK,CAACG,MAAM,CACdC,GAAG,CAACC,KAAK,IAAIC,WAAW,CAAC;IAAEN,KAAK;IAAEC,IAAI;IAAEI,KAAK;IAAEH;EAAiB,CAAC,CAAC,CAAC,CACnEK,MAAM,CAACC,OAAO,CAAC;AACxB,CAAC;AAAC;AAMK,MAAMF,WAAW,GAAG,CAAC;EACxBN,KAAK;EACLC,IAAI;EACJI,KAAK;EACLH;AACe,CAAC,KAAqC;EACrD,MAAMO,MAAoC,GAAGP,gBAAgB,CAAC,IAAAQ,kCAAgB,EAACL,KAAK,CAAC,CAAC;EACtF,IAAI,CAACI,MAAM,EAAE;IACT;IACA,OAAO,IAAI;EACf;EACA,MAAME,IAAI,GAAGF,MAAM,CAACR,IAAI,CAAC,CAACW,eAAe,CAAC;IACtCZ,KAAK;IACLK,KAAK;IACLH;EACJ,CAAC,CAAC;EAEF,IAAI,CAACS,IAAI,EAAE;IACP,OAAO,IAAI;EACf,CAAC,MAAM,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IACjC,OAAO;MACHR,MAAM,EAAEQ;IACZ,CAAC;EACL;EAEA,OAAOA,IAAI;AACf,CAAC;AAAC"}
+{"version":3,"names":["getBaseFieldType","renderFields","models","model","fields","type","fieldTypePlugins","map","field","renderField","filter","Boolean","plugin","Error","createTypeField","defs"],"sources":["renderFields.ts"],"sourcesContent":["import type {\n    ApiEndpoint,\n    CmsFieldTypePlugins,\n    CmsModel,\n    CmsModelField,\n    CmsModelFieldDefinition,\n    CmsModelFieldToGraphQLPlugin\n} from \"~/types/index.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\n\ninterface RenderFieldsParams {\n    models: CmsModel[];\n    model: CmsModel;\n    fields: CmsModelField[];\n    type: ApiEndpoint;\n    fieldTypePlugins: CmsFieldTypePlugins;\n}\n\ninterface RenderFields {\n    (params: RenderFieldsParams): CmsModelFieldDefinition[];\n}\n\nexport const renderFields: RenderFields = ({\n    models,\n    model,\n    fields,\n    type,\n    fieldTypePlugins\n}): CmsModelFieldDefinition[] => {\n    return fields\n        .map(field => renderField({ models, model, type, field, fieldTypePlugins }))\n        .filter(Boolean) as CmsModelFieldDefinition[];\n};\n\ninterface RenderFieldParams extends Omit<RenderFieldsParams, \"fields\"> {\n    field: CmsModelField;\n}\n\nexport const renderField = ({\n    models,\n    model,\n    type,\n    field,\n    fieldTypePlugins\n}: RenderFieldParams): CmsModelFieldDefinition | null => {\n    const plugin = fieldTypePlugins[getBaseFieldType(field)];\n    if (!plugin) {\n        // Let's not render the field if it does not exist in the field plugins.\n        return null;\n    } else if (!plugin[type]) {\n        throw new Error(`Missing \"${type}\" plugin for field type \"${field.type}\".`);\n    }\n    const { createTypeField } = plugin[type] as CmsModelFieldToGraphQLPlugin[\"manage\"];\n    const defs = createTypeField({\n        models,\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":"AAQA,SAASA,gBAAgB;AAczB,OAAO,MAAMC,YAA0B,GAAGA,CAAC;EACvCC,MAAM;EACNC,KAAK;EACLC,MAAM;EACNC,IAAI;EACJC;AACJ,CAAC,KAAgC;EAC7B,OAAOF,MAAM,CACRG,GAAG,CAACC,KAAK,IAAIC,WAAW,CAAC;IAAEP,MAAM;IAAEC,KAAK;IAAEE,IAAI;IAAEG,KAAK;IAAEF;EAAiB,CAAC,CAAC,CAAC,CAC3EI,MAAM,CAACC,OAAO,CAAC;AACxB,CAAC;AAMD,OAAO,MAAMF,WAAW,GAAGA,CAAC;EACxBP,MAAM;EACNC,KAAK;EACLE,IAAI;EACJG,KAAK;EACLF;AACe,CAAC,KAAqC;EACrD,MAAMM,MAAM,GAAGN,gBAAgB,CAACN,gBAAgB,CAACQ,KAAK,CAAC,CAAC;EACxD,IAAI,CAACI,MAAM,EAAE;IACT;IACA,OAAO,IAAI;EACf,CAAC,MAAM,IAAI,CAACA,MAAM,CAACP,IAAI,CAAC,EAAE;IACtB,MAAM,IAAIQ,KAAK,CAAC,YAAYR,IAAI,4BAA4BG,KAAK,CAACH,IAAI,IAAI,CAAC;EAC/E;EACA,MAAM;IAAES;EAAgB,CAAC,GAAGF,MAAM,CAACP,IAAI,CAA2C;EAClF,MAAMU,IAAI,GAAGD,eAAe,CAAC;IACzBZ,MAAM;IACNC,KAAK;IACLK,KAAK;IACLF;EACJ,CAAC,CAAC;EAEF,IAAI,CAACS,IAAI,EAAE;IACP,OAAO,IAAI;EACf,CAAC,MAAM,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IACjC,OAAO;MACHX,MAAM,EAAEW;IACZ,CAAC;EACL;EAEA,OAAOA,IAAI;AACf,CAAC","ignoreList":[]}

package/utils/renderGetFilterFields.d.ts

@@ -1,10 +1,17 @@
-import { CmsFieldTypePlugins, CmsModel } from "../types";
+import type { CmsFieldTypePlugins, CmsModelField } from "../types/index.js";
 interface RenderGetFilterFieldsParams {
-    model: CmsModel;
+    fields: CmsModelField[];
     fieldTypePlugins: CmsFieldTypePlugins;
 }
+interface RenderGetFilterFieldsResponse {
+    baseFilters: string[];
+    baseFiltersAsString(): string;
+    fieldFilters: string[];
+    fieldFiltersAsString(): string;
+    allFiltersAsString(): string;
+}
 interface RenderGetFilterFields {
-    (params: RenderGetFilterFieldsParams): string;
+    (params: RenderGetFilterFieldsParams): RenderGetFilterFieldsResponse;
 }
 export declare const renderGetFilterFields: RenderGetFilterFields;
 export {};

package/utils/renderGetFilterFields.js

@@ -1,48 +1,42 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.renderGetFilterFields = void 0;
-var _getBaseFieldType = require("./getBaseFieldType");
-const getCreateFilters = (plugins, fieldType) => {
-  if (!plugins[fieldType] || !plugins[fieldType].read.createGetFilters) {
-    return null;
-  }
-  return plugins[fieldType].read.createGetFilters;
-};
-const renderGetFilterFields = ({
-  model,
+import { getBaseFieldType } from "./getBaseFieldType.js";
+export const renderGetFilterFields = ({
+  fields,
   fieldTypePlugins
 }) => {
-  const fieldIdList = model.fields.filter(field => {
+  const baseFilters = ["id: ID", "entryId: String"];
+  const fieldFilters = [];
+  for (const field of 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 baseType = (0, _getBaseFieldType.getBaseFieldType)(field);
-    if (!fieldTypePlugins[baseType]) {
-      return false;
-    }
-    return fieldTypePlugins[baseType].isSearchable;
-  }).map(f => f.fieldId);
-  const filters = ["id: ID", "entryId: String"];
-  for (const fieldId of fieldIdList) {
-    const field = model.fields.find(item => item.fieldId === fieldId);
-    if (!field) {
+    const baseType = getBaseFieldType(field);
+    const plugin = fieldTypePlugins[baseType];
+    if (!plugin?.isSearchable) {
       continue;
     }
-    const baseType = (0, _getBaseFieldType.getBaseFieldType)(field);
-    const createGetFilters = getCreateFilters(fieldTypePlugins, baseType);
+    const createGetFilters = plugin.read?.createGetFilters;
     if (typeof createGetFilters !== "function") {
       continue;
     }
-    filters.push(createGetFilters({
-      model,
+    fieldFilters.push(createGetFilters({
       field
     }));
   }
-  return filters.filter(Boolean).join("\n");
+  return {
+    baseFilters,
+    fieldFilters,
+    baseFiltersAsString() {
+      return baseFilters.join("\n");
+    },
+    fieldFiltersAsString() {
+      return fieldFilters.join("\n");
+    },
+    allFiltersAsString() {
+      return [...baseFilters, ...fieldFilters].join("\n");
+    }
+  };
 };
-exports.renderGetFilterFields = renderGetFilterFields;
+
+//# sourceMappingURL=renderGetFilterFields.js.map

package/utils/renderGetFilterFields.js.map

@@ -1 +1 @@
-{"version":3,"names":["getCreateFilters","plugins","fieldType","read","createGetFilters","renderGetFilterFields","model","fieldTypePlugins","fieldIdList","fields","filter","field","baseType","getBaseFieldType","isSearchable","map","f","fieldId","filters","find","item","push","Boolean","join"],"sources":["renderGetFilterFields.ts"],"sourcesContent":["import { CmsFieldTypePlugins, CmsModel, CmsModelFieldToGraphQLPlugin } from \"~/types\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType\";\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            const baseType = getBaseFieldType(field);\n            if (!fieldTypePlugins[baseType]) {\n                return false;\n            }\n            return fieldTypePlugins[baseType].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 baseType = getBaseFieldType(field);\n        const createGetFilters = getCreateFilters(fieldTypePlugins, baseType);\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":";;;;;;AACA;AAUA,MAAMA,gBAAgB,GAAG,CACrBC,OAA4B,EAC5BC,SAAiB,KACiD;EAClE,IAAI,CAACD,OAAO,CAACC,SAAS,CAAC,IAAI,CAACD,OAAO,CAACC,SAAS,CAAC,CAACC,IAAI,CAACC,gBAAgB,EAAE;IAClE,OAAO,IAAI;EACf;EACA,OAAOH,OAAO,CAACC,SAAS,CAAC,CAACC,IAAI,CAACC,gBAAgB;AACnD,CAAC;AAEM,MAAMC,qBAA4C,GAAG,CAAC;EAAEC,KAAK;EAAEC;AAAiB,CAAC,KAAK;EACzF,MAAMC,WAAW,GAAGF,KAAK,CAACG,MAAM,CAC3BC,MAAM,CAACC,KAAK,IAAI;IACb;IACA;IACA;IACA;IACA;IACA,MAAMC,QAAQ,GAAG,IAAAC,kCAAgB,EAACF,KAAK,CAAC;IACxC,IAAI,CAACJ,gBAAgB,CAACK,QAAQ,CAAC,EAAE;MAC7B,OAAO,KAAK;IAChB;IACA,OAAOL,gBAAgB,CAACK,QAAQ,CAAC,CAACE,YAAY;EAClD,CAAC,CAAC,CACDC,GAAG,CAACC,CAAC,IAAIA,CAAC,CAACC,OAAO,CAAC;EAExB,MAAMC,OAAiB,GAAG,CAAC,QAAQ,EAAE,iBAAiB,CAAC;EAEvD,KAAK,MAAMD,OAAO,IAAIT,WAAW,EAAE;IAC/B,MAAMG,KAAK,GAAGL,KAAK,CAACG,MAAM,CAACU,IAAI,CAACC,IAAI,IAAIA,IAAI,CAACH,OAAO,KAAKA,OAAO,CAAC;IACjE,IAAI,CAACN,KAAK,EAAE;MACR;IACJ;IACA,MAAMC,QAAQ,GAAG,IAAAC,kCAAgB,EAACF,KAAK,CAAC;IACxC,MAAMP,gBAAgB,GAAGJ,gBAAgB,CAACO,gBAAgB,EAAEK,QAAQ,CAAC;IACrE,IAAI,OAAOR,gBAAgB,KAAK,UAAU,EAAE;MACxC;IACJ;IACAc,OAAO,CAACG,IAAI,CAACjB,gBAAgB,CAAC;MAAEE,KAAK;MAAEK;IAAM,CAAC,CAAC,CAAC;EACpD;EAEA,OAAOO,OAAO,CAACR,MAAM,CAACY,OAAO,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC;AAC7C,CAAC;AAAC"}
+{"version":3,"names":["getBaseFieldType","renderGetFilterFields","fields","fieldTypePlugins","baseFilters","fieldFilters","field","baseType","plugin","isSearchable","createGetFilters","read","push","baseFiltersAsString","join","fieldFiltersAsString","allFiltersAsString"],"sources":["renderGetFilterFields.ts"],"sourcesContent":["import type { CmsFieldTypePlugins, CmsModelField } from \"~/types/index.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\n\ninterface RenderGetFilterFieldsParams {\n    fields: CmsModelField[];\n    fieldTypePlugins: CmsFieldTypePlugins;\n}\ninterface RenderGetFilterFieldsResponse {\n    baseFilters: string[];\n    baseFiltersAsString(): string;\n    fieldFilters: string[];\n    fieldFiltersAsString(): string;\n    allFiltersAsString(): string;\n}\n\ninterface RenderGetFilterFields {\n    (params: RenderGetFilterFieldsParams): RenderGetFilterFieldsResponse;\n}\n\nexport const renderGetFilterFields: RenderGetFilterFields = ({\n    fields,\n    fieldTypePlugins\n}): RenderGetFilterFieldsResponse => {\n    const baseFilters: string[] = [\"id: ID\", \"entryId: String\"];\n\n    const fieldFilters: string[] = [];\n\n    for (const field of fields) {\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 baseType = getBaseFieldType(field);\n        const plugin = fieldTypePlugins[baseType];\n        if (!plugin?.isSearchable) {\n            continue;\n        }\n        const createGetFilters = plugin.read?.createGetFilters;\n        if (typeof createGetFilters !== \"function\") {\n            continue;\n        }\n        fieldFilters.push(createGetFilters({ field }));\n    }\n    return {\n        baseFilters,\n        fieldFilters,\n        baseFiltersAsString() {\n            return baseFilters.join(\"\\n\");\n        },\n        fieldFiltersAsString() {\n            return fieldFilters.join(\"\\n\");\n        },\n        allFiltersAsString() {\n            return [...baseFilters, ...fieldFilters].join(\"\\n\");\n        }\n    };\n};\n"],"mappings":"AACA,SAASA,gBAAgB;AAkBzB,OAAO,MAAMC,qBAA4C,GAAGA,CAAC;EACzDC,MAAM;EACNC;AACJ,CAAC,KAAoC;EACjC,MAAMC,WAAqB,GAAG,CAAC,QAAQ,EAAE,iBAAiB,CAAC;EAE3D,MAAMC,YAAsB,GAAG,EAAE;EAEjC,KAAK,MAAMC,KAAK,IAAIJ,MAAM,EAAE;IACxB;IACA;IACA;IACA;IACA;IACA,MAAMK,QAAQ,GAAGP,gBAAgB,CAACM,KAAK,CAAC;IACxC,MAAME,MAAM,GAAGL,gBAAgB,CAACI,QAAQ,CAAC;IACzC,IAAI,CAACC,MAAM,EAAEC,YAAY,EAAE;MACvB;IACJ;IACA,MAAMC,gBAAgB,GAAGF,MAAM,CAACG,IAAI,EAAED,gBAAgB;IACtD,IAAI,OAAOA,gBAAgB,KAAK,UAAU,EAAE;MACxC;IACJ;IACAL,YAAY,CAACO,IAAI,CAACF,gBAAgB,CAAC;MAAEJ;IAAM,CAAC,CAAC,CAAC;EAClD;EACA,OAAO;IACHF,WAAW;IACXC,YAAY;IACZQ,mBAAmBA,CAAA,EAAG;MAClB,OAAOT,WAAW,CAACU,IAAI,CAAC,IAAI,CAAC;IACjC,CAAC;IACDC,oBAAoBA,CAAA,EAAG;MACnB,OAAOV,YAAY,CAACS,IAAI,CAAC,IAAI,CAAC;IAClC,CAAC;IACDE,kBAAkBA,CAAA,EAAG;MACjB,OAAO,CAAC,GAAGZ,WAAW,EAAE,GAAGC,YAAY,CAAC,CAACS,IAAI,CAAC,IAAI,CAAC;IACvD;EACJ,CAAC;AACL,CAAC","ignoreList":[]}

package/utils/renderInputFields.d.ts

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