@webiny/api-headless-cms 0.0.0-unstable.78f581c1d2 → 0.0.0-unstable.7be00a75a9

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,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"}
+{"version":3,"file":"utils/getEntryTitle.js","sources":["../../src/utils/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"],"names":["getEntryTitle","model","entry","field","f","titleFieldId","titleValue","enabled","values","Array","value"],"mappings":"AAEO,SAASA,cACZC,KAAgD,EAChDC,KAAyC;IAEzC,IAAI,CAACD,MAAM,YAAY,EACnB,OAAOC,MAAM,EAAE;IAEnB,MAAMC,QAAQF,MAAM,MAAM,CAAC,IAAI,CAACG,CAAAA,IAAKA,EAAE,OAAO,KAAKH,MAAM,YAAY;IACrE,IAAI,CAACE,OACD,OAAOD,MAAM,EAAE;IAEnB,MAAMG,eAAeF,MAAM,OAAO;IAClC,MAAMG,aAAaJ,MAAM,MAAM,CAACG,aAAa;IAC7C,IAAI,CAACC,cAAc,AAAsB,YAAtB,OAAOA,YACtB,OAAOJ,MAAM,EAAE;IAGnB,MAAM,EAAEK,UAAU,KAAK,EAAEC,MAAM,EAAE,GAAGL,MAAM,gBAAgB,IAAI,CAAC;IAC/D,IAAI,CAACI,WAAW,CAACC,UAAUC,AAA0B,UAA1BA,MAAM,OAAO,CAACD,SACrC,OAAOF;IAEX,KAAK,MAAMI,SAASF,OAEhB,IAAIE,MAAM,KAAK,IAAIJ,YACf,OAAOI,MAAM,KAAK;IAG1B,OAAOJ;AACX"}

package/utils/getSchemaFromFieldPlugins.d.ts

@@ -1,12 +1,21 @@
-import { CmsModel, CmsContext, CmsFieldTypePlugins, ApiEndpoint } from "../types";
-import { GraphQLSchemaDefinition } from "@webiny/handler-graphql/types";
-interface RenderTypesFromFieldPluginsParams {
+import type { ApiEndpoint, CmsContext, 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";
+import type { CmsModelFieldToGraphQLRegistry } from "../features/graphql/index.js";
+interface CreatePluginCallableParams {
+    schema: GraphQLSchemaDefinition<CmsContext>;
+    type: "manage" | "preview" | "read";
+    fieldType: string;
+}
+interface CreatePluginCallable {
+    (params: CreatePluginCallableParams): IGraphQLSchemaPlugin<CmsContext>;
+}
+interface Params {
     models: CmsModel[];
-    fieldTypePlugins: CmsFieldTypePlugins;
+    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;
     type: ApiEndpoint;
+    createPlugin?: CreatePluginCallable;
 }
-interface RenderTypesFromFieldPlugins {
-    (params: RenderTypesFromFieldPluginsParams): GraphQLSchemaDefinition<CmsContext>[];
-}
-export declare const getSchemaFromFieldPlugins: RenderTypesFromFieldPlugins;
+export declare const createGraphQLSchemaPluginFromFieldPlugins: (params: Params) => ICmsGraphQLSchemaPlugin[];
 export {};

package/utils/getSchemaFromFieldPlugins.js

@@ -1,35 +1,35 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getSchemaFromFieldPlugins = void 0;
+import { createCmsGraphQLSchemaPlugin } from "../plugins/index.js";
 const TYPE_MAP = {
-  preview: "read",
-  read: "read",
-  manage: "manage"
+    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;
+const defaultCreatePlugin = ({ schema, type, fieldType })=>{
+    const plugin = createCmsGraphQLSchemaPlugin(schema);
+    plugin.name = `headless-cms.graphql.schema.${type}.field.${fieldType}`;
+    return plugin;
+};
+const createGraphQLSchemaPluginFromFieldPlugins = (params)=>{
+    const { models, fieldRegistry, type, createPlugin = defaultCreatePlugin } = params;
+    const apiType = TYPE_MAP[type];
+    const plugins = [];
+    for (const fieldTypePlugin of fieldRegistry.getAll()){
+        const api = "manage" === apiType ? fieldTypePlugin.manage : fieldTypePlugin.read;
+        if (!apiType || !api) continue;
+        const createSchema = api.createSchema;
+        if (!createSchema) continue;
+        const schema = createSchema({
+            models
+        });
+        const plugin = createPlugin({
+            schema,
+            type,
+            fieldType: fieldTypePlugin.fieldType
+        });
+        plugins.push(plugin);
     }
-
-    return createSchema({
-      models
-    });
-  }).filter(Boolean);
+    return plugins;
 };
+export { createGraphQLSchemaPluginFromFieldPlugins };
 
-exports.getSchemaFromFieldPlugins = getSchemaFromFieldPlugins;
+//# sourceMappingURL=getSchemaFromFieldPlugins.js.map

package/utils/getSchemaFromFieldPlugins.js.map

@@ -1 +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"}
+{"version":3,"file":"utils/getSchemaFromFieldPlugins.js","sources":["../../src/utils/getSchemaFromFieldPlugins.ts"],"sourcesContent":["import type { ApiEndpoint, CmsContext, 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\";\nimport type { CmsModelFieldToGraphQLRegistry } from \"~/features/graphql/index.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    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\n    type: ApiEndpoint;\n    createPlugin?: CreatePluginCallable;\n}\nexport const createGraphQLSchemaPluginFromFieldPlugins = (params: Params) => {\n    const { models, fieldRegistry, type, createPlugin = defaultCreatePlugin } = params;\n\n    const apiType = TYPE_MAP[type];\n\n    const plugins: ICmsGraphQLSchemaPlugin[] = [];\n    for (const fieldTypePlugin of fieldRegistry.getAll()) {\n        const api = apiType === \"manage\" ? fieldTypePlugin.manage : fieldTypePlugin.read;\n        if (!apiType || !api) {\n            continue;\n        }\n        const createSchema = api.createSchema;\n        if (!createSchema) {\n            continue;\n        }\n        const schema = createSchema({ models });\n\n        const plugin = createPlugin({\n            schema,\n            type,\n            fieldType: fieldTypePlugin.fieldType\n        });\n        plugins.push(plugin);\n    }\n    return plugins;\n};\n"],"names":["TYPE_MAP","defaultCreatePlugin","schema","type","fieldType","plugin","createCmsGraphQLSchemaPlugin","createGraphQLSchemaPluginFromFieldPlugins","params","models","fieldRegistry","createPlugin","apiType","plugins","fieldTypePlugin","api","createSchema"],"mappings":";AAOA,MAAMA,WAA8C;IAChD,SAAS;IACT,MAAM;IACN,QAAQ;AACZ;AAYA,MAAMC,sBAA4C,CAAC,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAE;IAC1E,MAAMC,SAASC,6BAA6BJ;IAC5CG,OAAO,IAAI,GAAG,CAAC,4BAA4B,EAAEF,KAAK,OAAO,EAAEC,WAAW;IACtE,OAAOC;AACX;AAQO,MAAME,4CAA4C,CAACC;IACtD,MAAM,EAAEC,MAAM,EAAEC,aAAa,EAAEP,IAAI,EAAEQ,eAAeV,mBAAmB,EAAE,GAAGO;IAE5E,MAAMI,UAAUZ,QAAQ,CAACG,KAAK;IAE9B,MAAMU,UAAqC,EAAE;IAC7C,KAAK,MAAMC,mBAAmBJ,cAAc,MAAM,GAAI;QAClD,MAAMK,MAAMH,AAAY,aAAZA,UAAuBE,gBAAgB,MAAM,GAAGA,gBAAgB,IAAI;QAChF,IAAI,CAACF,WAAW,CAACG,KACb;QAEJ,MAAMC,eAAeD,IAAI,YAAY;QACrC,IAAI,CAACC,cACD;QAEJ,MAAMd,SAASc,aAAa;YAAEP;QAAO;QAErC,MAAMJ,SAASM,aAAa;YACxBT;YACAC;YACA,WAAWW,gBAAgB,SAAS;QACxC;QACAD,QAAQ,IAAI,CAACR;IACjB;IACA,OAAOQ;AACX"}

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,12 @@
+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
+    };
+}
+export { getIdentity };
+
+//# sourceMappingURL=identity.js.map

package/utils/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/identity.js","sources":["../../src/utils/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"],"names":["getIdentity","input","defaultValue","identity"],"mappings":"AAoBO,SAASA,YACZC,KAAwD,EACxDC,YAAoD;IAEpD,MAAMC,WAAWF,OAAO,MAAMA,OAAO,eAAeA,OAAO,OAAOA,QAAQC;IAE1E,IAAI,CAACC,UACD,OAAO;IAGX,OAAO;QACH,IAAIA,SAAS,EAAE;QACf,aAAaA,SAAS,WAAW;QACjC,MAAMA,SAAS,IAAI;IACvB;AACJ"}

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,19 @@
+import { createIdentifier, parseIdentifier } from "@webiny/utils";
+import error from "@webiny/error";
+const incrementEntryIdVersion = (id)=>{
+    const { id: entryId, version } = parseIdentifier(id);
+    if (!version) throw new error("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
+        })
+    };
+};
+export { incrementEntryIdVersion };
+
+//# sourceMappingURL=incrementEntryIdVersion.js.map

package/utils/incrementEntryIdVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/incrementEntryIdVersion.js","sources":["../../src/utils/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"],"names":["incrementEntryIdVersion","id","entryId","version","parseIdentifier","WebinyError","createIdentifier"],"mappings":";;AAGO,MAAMA,0BAA0B,CAACC;IACpC,MAAM,EAAE,IAAIC,OAAO,EAAEC,OAAO,EAAE,GAAGC,gBAAgBH;IACjD,IAAI,CAACE,SACD,MAAM,IAAIE,MACN,+DACA,YACA;QACIJ;IACJ;IAGR,OAAO;QACHC;QACA,SAASC,UAAU;QACnB,IAAIG,iBAAiB;YACjB,IAAIJ;YACJ,SAASC,UAAU;QACvB;IACJ;AACJ"}

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,2 @@
+export * from "./caching/index.js";
+export * from "./modelFieldTraverser/index.js";

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,8 @@
+const isHeadlessCmsReady = async ({ tenancy })=>{
+    const tenant = tenancy.getCurrentTenant();
+    if (!tenant) return false;
+    return true;
+};
+export { isHeadlessCmsReady };
+
+//# sourceMappingURL=isHeadlessCmsReady.js.map

package/utils/isHeadlessCmsReady.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/isHeadlessCmsReady.js","sources":["../../src/utils/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"],"names":["isHeadlessCmsReady","tenancy","tenant"],"mappings":"AAKO,MAAMA,qBAAqB,OAAO,EAAEC,OAAO,EAAc;IAI5D,MAAMC,SAASD,QAAQ,gBAAgB;IACvC,IAAI,CAACC,QACD,OAAO;IAGX,OAAO;AACX"}

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,32 @@
+const nodeHasChildren = (node)=>node.children.length > 0;
+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 ("collection" === node.type) return parent.field;
+        return node.field;
+    }
+}
+export { ModelFieldTraverser };
+
+//# sourceMappingURL=ModelFieldTraverser.js.map

package/utils/modelFieldTraverser/ModelFieldTraverser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/modelFieldTraverser/ModelFieldTraverser.js","sources":["../../../src/utils/modelFieldTraverser/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"],"names":["nodeHasChildren","node","ModelFieldTraverser","modelAst","onField","root","path","field","parent"],"mappings":"AAOA,MAAMA,kBAAkB,CAACC,OACdA,KAAK,QAAQ,CAAC,MAAM,GAAG;AAuB3B,MAAMC;IACF,SAASC,QAAqB,EAAEC,OAAoD,EAAE;QACzF,IAAI,CAAC,OAAO,CAACD,UAAU,EAAE,EAAEC;IAC/B;IAEQ,QACJC,IAAwC,EACxCC,IAAc,EACdF,OAAoD,EACtD;QACE,KAAK,MAAMH,QAAQI,KAAK,QAAQ,CAAE;YAC9B,MAAME,QAAQ,IAAI,CAAC,gBAAgB,CAAC;gBAAEN;gBAAM,QAAQI;YAAK;YACzDD,QAAQ;gBACJG;gBACA,MAAM;uBAAID;oBAAMC,MAAM,OAAO;iBAAC;YAClC;YAEA,IAAIP,gBAAgBC,OAChB,IAAI,CAAC,OAAO,CAACA,MAAM;mBAAIK;gBAAMC,MAAM,OAAO;aAAC,EAAEH;QAErD;IACJ;IAEQ,iBAAiB,EAAEH,IAAI,EAAEO,MAAM,EAAmB,EAAE;QACxD,IAAIP,AAAc,iBAAdA,KAAK,IAAI,EACT,OAAQO,OAAqC,KAAK;QAGtD,OAAQP,KAAmC,KAAK;IACpD;AACJ"}

package/utils/modelFieldTraverser/index.d.ts

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

package/utils/modelFieldTraverser/index.js

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

package/utils/renderFields.d.ts

@@ -1,15 +1,18 @@
-import { ApiEndpoint, CmsFieldTypePlugins, CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types";
+import type { ApiEndpoint, CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types/index.js";
+import type { CmsModelFieldToGraphQLRegistry } from "../features/graphql/index.js";
 interface RenderFieldsParams {
+    models: CmsModel[];
     model: CmsModel;
+    fields: CmsModelField[];
     type: ApiEndpoint;
-    fieldTypePlugins: CmsFieldTypePlugins;
+    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;
 }
 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, fieldRegistry }: RenderFieldParams) => CmsModelFieldDefinition | null;
 export {};

package/utils/renderFields.js

@@ -1,53 +1,32 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.renderFields = exports.renderField = void 0;
-
-const renderFields = ({
-  model,
-  type,
-  fieldTypePlugins
-}) => {
-  return model.fields.map(field => renderField({
-    model,
-    type,
-    field,
-    fieldTypePlugins
-  })).filter(Boolean);
+import { getBaseFieldType } from "./getBaseFieldType.js";
+const getFieldApi = (field, type)=>{
+    if ("manage" === type) return field.manage;
+    return field.read;
 };
-
-exports.renderFields = renderFields;
-
-const renderField = ({
-  model,
-  type,
-  field,
-  fieldTypePlugins
-}) => {
-  const plugin = fieldTypePlugins[field.type];
-
-  if (!plugin) {
-    // Let's not render the field if it does not exist in the field plugins.
-    return null;
-  }
-
-  const defs = plugin[type].createTypeField({
-    model,
-    field,
-    fieldTypePlugins
-  });
-
-  if (!defs) {
-    return null;
-  } else if (typeof defs === "string") {
-    return {
-      fields: defs
+const renderFields = ({ models, model, fields, type, fieldRegistry })=>fields.map((field)=>renderField({
+            models,
+            model,
+            type,
+            field,
+            fieldRegistry
+        })).filter(Boolean);
+const renderField = ({ models, model, type, field, fieldRegistry })=>{
+    const plugin = fieldRegistry.get(getBaseFieldType(field));
+    if (!plugin) return null;
+    const api = getFieldApi(plugin, type);
+    const { createTypeField } = api;
+    const defs = createTypeField({
+        models,
+        model,
+        field,
+        fieldRegistry
+    });
+    if (!defs) return null;
+    if ("string" == typeof defs) return {
+        fields: defs
     };
-  }
-
-  return defs;
+    return defs;
 };
+export { renderField, renderFields };
 
-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","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"}
+{"version":3,"file":"utils/renderFields.js","sources":["../../src/utils/renderFields.ts"],"sourcesContent":["import type {\n    ApiEndpoint,\n    CmsModel,\n    CmsModelField,\n    CmsModelFieldDefinition\n} from \"~/types/index.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\nimport type {\n    CmsModelFieldToGraphQL,\n    CmsModelFieldToGraphQLRegistry\n} from \"~/features/graphql/index.js\";\n\nconst getFieldApi = (\n    field: CmsModelFieldToGraphQL.Interface,\n    type: ApiEndpoint\n): CmsModelFieldToGraphQL.ManageApi => {\n    if (type === \"manage\") {\n        return field.manage;\n    }\n    /* \"read\" and \"preview\" both use the read API. */\n    return field.read as CmsModelFieldToGraphQL.ManageApi;\n};\n\ninterface RenderFieldsParams {\n    models: CmsModel[];\n    model: CmsModel;\n    fields: CmsModelField[];\n    type: ApiEndpoint;\n    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\n}\n\ninterface RenderFields {\n    (params: RenderFieldsParams): CmsModelFieldDefinition[];\n}\n\nexport const renderFields: RenderFields = ({\n    models,\n    model,\n    fields,\n    type,\n    fieldRegistry\n}): CmsModelFieldDefinition[] => {\n    return fields\n        .map(field => renderField({ models, model, type, field, fieldRegistry }))\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    fieldRegistry\n}: RenderFieldParams): CmsModelFieldDefinition | null => {\n    const plugin = fieldRegistry.get(getBaseFieldType(field));\n    if (!plugin) {\n        return null;\n    }\n    const api = getFieldApi(plugin, type);\n    const { createTypeField } = api;\n    const defs = createTypeField({\n        models,\n        model,\n        field,\n        fieldRegistry\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"],"names":["getFieldApi","field","type","renderFields","models","model","fields","fieldRegistry","renderField","Boolean","plugin","getBaseFieldType","api","createTypeField","defs"],"mappings":";AAYA,MAAMA,cAAc,CAChBC,OACAC;IAEA,IAAIA,AAAS,aAATA,MACA,OAAOD,MAAM,MAAM;IAGvB,OAAOA,MAAM,IAAI;AACrB;AAcO,MAAME,eAA6B,CAAC,EACvCC,MAAM,EACNC,KAAK,EACLC,MAAM,EACNJ,IAAI,EACJK,aAAa,EAChB,GACUD,OACF,GAAG,CAACL,CAAAA,QAASO,YAAY;YAAEJ;YAAQC;YAAOH;YAAMD;YAAOM;QAAc,IACrE,MAAM,CAACE;AAOT,MAAMD,cAAc,CAAC,EACxBJ,MAAM,EACNC,KAAK,EACLH,IAAI,EACJD,KAAK,EACLM,aAAa,EACG;IAChB,MAAMG,SAASH,cAAc,GAAG,CAACI,iBAAiBV;IAClD,IAAI,CAACS,QACD,OAAO;IAEX,MAAME,MAAMZ,YAAYU,QAAQR;IAChC,MAAM,EAAEW,eAAe,EAAE,GAAGD;IAC5B,MAAME,OAAOD,gBAAgB;QACzBT;QACAC;QACAJ;QACAM;IACJ;IAEA,IAAI,CAACO,MACD,OAAO;IACJ,IAAI,AAAgB,YAAhB,OAAOA,MACd,OAAO;QACH,QAAQA;IACZ;IAGJ,OAAOA;AACX"}

package/utils/renderGetFilterFields.d.ts

@@ -1,10 +1,18 @@
-import { CmsFieldTypePlugins, CmsModel } from "../types";
+import type { CmsModelField } from "../types/index.js";
+import type { CmsModelFieldToGraphQLRegistry } from "../features/graphql/index.js";
 interface RenderGetFilterFieldsParams {
-    model: CmsModel;
-    fieldTypePlugins: CmsFieldTypePlugins;
+    fields: CmsModelField[];
+    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;
+}
+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,56 +1,36 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.renderGetFilterFields = void 0;
-
-const getCreateFilters = (plugins, fieldType) => {
-  if (!plugins[fieldType] || !plugins[fieldType].read.createGetFilters) {
-    return null;
-  }
-
-  return plugins[fieldType].read.createGetFilters;
-};
-
-const renderGetFilterFields = ({
-  model,
-  fieldTypePlugins
-}) => {
-  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.
-    if (!fieldTypePlugins[field.type]) {
-      return false;
-    }
-
-    return fieldTypePlugins[field.type].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) {
-      continue;
+import { getBaseFieldType } from "./getBaseFieldType.js";
+const renderGetFilterFields = ({ fields, fieldRegistry })=>{
+    const baseFilters = [
+        "id: ID",
+        "entryId: String"
+    ];
+    const fieldFilters = [];
+    for (const field of fields){
+        const baseType = getBaseFieldType(field);
+        const plugin = fieldRegistry.get(baseType);
+        if (!plugin?.isSearchable) continue;
+        const createGetFilters = plugin.read?.createGetFilters;
+        if ("function" == typeof createGetFilters) fieldFilters.push(createGetFilters({
+            field
+        }));
     }
-
-    const createGetFilters = getCreateFilters(fieldTypePlugins, field.type);
-
-    if (typeof createGetFilters !== "function") {
-      continue;
-    }
-
-    filters.push(createGetFilters({
-      model,
-      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");
+        }
+    };
 };
+export { renderGetFilterFields };
 
-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","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"}
+{"version":3,"file":"utils/renderGetFilterFields.js","sources":["../../src/utils/renderGetFilterFields.ts"],"sourcesContent":["import type { CmsModelField } from \"~/types/index.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\nimport type { CmsModelFieldToGraphQLRegistry } from \"~/features/graphql/index.js\";\n\ninterface RenderGetFilterFieldsParams {\n    fields: CmsModelField[];\n    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\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    fieldRegistry\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 = fieldRegistry.get(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"],"names":["renderGetFilterFields","fields","fieldRegistry","baseFilters","fieldFilters","field","baseType","getBaseFieldType","plugin","createGetFilters"],"mappings":";AAoBO,MAAMA,wBAA+C,CAAC,EACzDC,MAAM,EACNC,aAAa,EAChB;IACG,MAAMC,cAAwB;QAAC;QAAU;KAAkB;IAE3D,MAAMC,eAAyB,EAAE;IAEjC,KAAK,MAAMC,SAASJ,OAAQ;QAMxB,MAAMK,WAAWC,iBAAiBF;QAClC,MAAMG,SAASN,cAAc,GAAG,CAACI;QACjC,IAAI,CAACE,QAAQ,cACT;QAEJ,MAAMC,mBAAmBD,OAAO,IAAI,EAAE;QACtC,IAAI,AAA4B,cAA5B,OAAOC,kBAGXL,aAAa,IAAI,CAACK,iBAAiB;YAAEJ;QAAM;IAC/C;IACA,OAAO;QACHF;QACAC;QACA;YACI,OAAOD,YAAY,IAAI,CAAC;QAC5B;QACA;YACI,OAAOC,aAAa,IAAI,CAAC;QAC7B;QACA;YACI,OAAO;mBAAID;mBAAgBC;aAAa,CAAC,IAAI,CAAC;QAClD;IACJ;AACJ"}

package/utils/renderInputFields.d.ts

@@ -1,14 +1,17 @@
-import { CmsFieldTypePlugins, CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types";
+import type { CmsModel, CmsModelField, CmsModelFieldDefinition } from "../types/index.js";
+import type { CmsModelFieldToGraphQLRegistry } from "../features/graphql/index.js";
 interface RenderInputFieldsParams {
+    models: CmsModel[];
     model: CmsModel;
-    fieldTypePlugins: CmsFieldTypePlugins;
+    fields: CmsModelField[];
+    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;
 }
-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, fieldRegistry }: RenderInputFieldParams) => CmsModelFieldDefinition | null;
 export {};