@webiny/api-headless-cms 0.0.0-unstable.06b2ede40f → 0.0.0-unstable.0d717d18dd

package/features/contentModelGroup/UpdateGroup/abstractions.d.ts

@@ -0,0 +1,42 @@
+import { Result } from "@webiny/feature/api";
+import type { CmsGroup, CmsGroupUpdateInput } from "../../../types/index.js";
+import type { GroupCannotUpdateCodeDefinedError, GroupPersistenceError, GroupValidationError } from "../../../domain/contentModelGroup/errors.js";
+import { GroupNotAuthorizedError, type GroupNotFoundError } from "../../../domain/contentModelGroup/errors.js";
+/**
+ * UpdateGroup Use Case
+ */
+export interface IUpdateGroupUseCase {
+    execute(groupId: string, input: CmsGroupUpdateInput): Promise<Result<CmsGroup, UseCaseError>>;
+}
+export interface IUpdateGroupUseCaseErrors {
+    notFound: GroupNotFoundError;
+    notAuthorized: GroupNotAuthorizedError;
+    validation: GroupValidationError;
+    repository: RepositoryError;
+}
+type UseCaseError = IUpdateGroupUseCaseErrors[keyof IUpdateGroupUseCaseErrors];
+/** Update a content model group. */
+export declare const UpdateGroupUseCase: import("@webiny/di").Abstraction<IUpdateGroupUseCase>;
+export declare namespace UpdateGroupUseCase {
+    type Interface = IUpdateGroupUseCase;
+    type Input = CmsGroupUpdateInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<CmsGroup, UseCaseError>>;
+}
+/**
+ * UpdateGroupRepository - Persists group updates to storage.
+ */
+export interface IUpdateGroupRepository {
+    execute(group: CmsGroup): Promise<Result<void, RepositoryError>>;
+}
+export interface IUpdateGroupRepositoryErrors {
+    cannotUpdate: GroupCannotUpdateCodeDefinedError;
+    storage: GroupPersistenceError;
+}
+type RepositoryError = IUpdateGroupRepositoryErrors[keyof IUpdateGroupRepositoryErrors];
+export declare const UpdateGroupRepository: import("@webiny/di").Abstraction<IUpdateGroupRepository>;
+export declare namespace UpdateGroupRepository {
+    type Interface = IUpdateGroupRepository;
+    type Error = RepositoryError;
+}
+export {};

package/features/contentModelGroup/UpdateGroup/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const UpdateGroupUseCase = createAbstraction("UpdateGroupUseCase");
+const UpdateGroupRepository = createAbstraction("UpdateGroupRepository");
+export { UpdateGroupRepository, UpdateGroupUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/contentModelGroup/UpdateGroup/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModelGroup/UpdateGroup/abstractions.js","sources":["../../../../src/features/contentModelGroup/UpdateGroup/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { CmsGroup, CmsGroupUpdateInput } from \"~/types/index.js\";\nimport type {\n    GroupCannotUpdateCodeDefinedError,\n    GroupPersistenceError,\n    GroupValidationError\n} from \"~/domain/contentModelGroup/errors.js\";\nimport {\n    GroupNotAuthorizedError,\n    type GroupNotFoundError\n} from \"~/domain/contentModelGroup/errors.js\";\n\n/**\n * UpdateGroup Use Case\n */\nexport interface IUpdateGroupUseCase {\n    execute(groupId: string, input: CmsGroupUpdateInput): Promise<Result<CmsGroup, UseCaseError>>;\n}\n\nexport interface IUpdateGroupUseCaseErrors {\n    notFound: GroupNotFoundError;\n    notAuthorized: GroupNotAuthorizedError;\n    validation: GroupValidationError;\n    repository: RepositoryError;\n}\n\ntype UseCaseError = IUpdateGroupUseCaseErrors[keyof IUpdateGroupUseCaseErrors];\n\n/** Update a content model group. */\nexport const UpdateGroupUseCase = createAbstraction<IUpdateGroupUseCase>(\"UpdateGroupUseCase\");\n\nexport namespace UpdateGroupUseCase {\n    export type Interface = IUpdateGroupUseCase;\n    export type Input = CmsGroupUpdateInput;\n\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<CmsGroup, UseCaseError>>;\n}\n\n/**\n * UpdateGroupRepository - Persists group updates to storage.\n */\nexport interface IUpdateGroupRepository {\n    execute(group: CmsGroup): Promise<Result<void, RepositoryError>>;\n}\n\nexport interface IUpdateGroupRepositoryErrors {\n    cannotUpdate: GroupCannotUpdateCodeDefinedError;\n    storage: GroupPersistenceError;\n}\n\ntype RepositoryError = IUpdateGroupRepositoryErrors[keyof IUpdateGroupRepositoryErrors];\n\nexport const UpdateGroupRepository =\n    createAbstraction<IUpdateGroupRepository>(\"UpdateGroupRepository\");\n\nexport namespace UpdateGroupRepository {\n    export type Interface = IUpdateGroupRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["UpdateGroupUseCase","createAbstraction","UpdateGroupRepository"],"mappings":";AA6BO,MAAMA,qBAAqBC,kBAAuC;AAwBlE,MAAMC,wBACTD,kBAA0C"}

package/features/contentModelGroup/UpdateGroup/events.d.ts

@@ -0,0 +1,58 @@
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { CmsGroup, CmsGroupUpdateInput } from "../../../types/index.js";
+/**
+ * Event payloads
+ */
+export interface GroupBeforeUpdateEventPayload {
+    original: CmsGroup;
+    group: CmsGroup;
+}
+export interface GroupAfterUpdateEventPayload {
+    original: CmsGroup;
+    group: CmsGroup;
+}
+export interface GroupUpdateErrorEventPayload {
+    input: CmsGroupUpdateInput;
+    original: CmsGroup;
+    group: CmsGroup;
+    error: Error;
+}
+/**
+ * GroupBeforeUpdateEvent - Published before updating a group
+ */
+export declare class GroupBeforeUpdateEvent extends DomainEvent<GroupBeforeUpdateEventPayload> {
+    eventType: "Cms/Group/BeforeUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<GroupBeforeUpdateEvent>>;
+}
+/** Hook into group lifecycle before a group is updated. */
+export declare const GroupBeforeUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<GroupBeforeUpdateEvent>>;
+export declare namespace GroupBeforeUpdateEventHandler {
+    type Interface = IEventHandler<GroupBeforeUpdateEvent>;
+    type Event = GroupBeforeUpdateEvent;
+}
+/**
+ * GroupAfterUpdateEvent - Published after updating a group
+ */
+export declare class GroupAfterUpdateEvent extends DomainEvent<GroupAfterUpdateEventPayload> {
+    eventType: "Cms/Group/AfterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<GroupAfterUpdateEvent>>;
+}
+/** Hook into group lifecycle after a group is updated. */
+export declare const GroupAfterUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<GroupAfterUpdateEvent>>;
+export declare namespace GroupAfterUpdateEventHandler {
+    type Interface = IEventHandler<GroupAfterUpdateEvent>;
+    type Event = GroupAfterUpdateEvent;
+}
+/**
+ * GroupUpdateErrorEvent - Published when update fails
+ */
+export declare class GroupUpdateErrorEvent extends DomainEvent<GroupUpdateErrorEventPayload> {
+    eventType: "Cms/Group/UpdateError";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<GroupUpdateErrorEvent>>;
+}
+export declare const GroupUpdateErrorEventHandler: import("@webiny/di").Abstraction<IEventHandler<GroupUpdateErrorEvent>>;
+export declare namespace GroupUpdateErrorEventHandler {
+    type Interface = IEventHandler<GroupUpdateErrorEvent>;
+    type Event = GroupUpdateErrorEvent;
+}

package/features/contentModelGroup/UpdateGroup/events.js

@@ -0,0 +1,32 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class GroupBeforeUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return GroupBeforeUpdateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Group/BeforeUpdate";
+    }
+}
+const GroupBeforeUpdateEventHandler = createAbstraction("GroupBeforeUpdateEventHandler");
+class GroupAfterUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return GroupAfterUpdateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Group/AfterUpdate";
+    }
+}
+const GroupAfterUpdateEventHandler = createAbstraction("GroupAfterUpdateEventHandler");
+class GroupUpdateErrorEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return GroupUpdateErrorEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Cms/Group/UpdateError";
+    }
+}
+const GroupUpdateErrorEventHandler = createAbstraction("GroupUpdateErrorEventHandler");
+export { GroupAfterUpdateEvent, GroupAfterUpdateEventHandler, GroupBeforeUpdateEvent, GroupBeforeUpdateEventHandler, GroupUpdateErrorEvent, GroupUpdateErrorEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/contentModelGroup/UpdateGroup/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModelGroup/UpdateGroup/events.js","sources":["../../../../src/features/contentModelGroup/UpdateGroup/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { CmsGroup, CmsGroupUpdateInput } from \"~/types/index.js\";\n\n/**\n * Event payloads\n */\nexport interface GroupBeforeUpdateEventPayload {\n    original: CmsGroup;\n    group: CmsGroup;\n}\n\nexport interface GroupAfterUpdateEventPayload {\n    original: CmsGroup;\n    group: CmsGroup;\n}\n\nexport interface GroupUpdateErrorEventPayload {\n    input: CmsGroupUpdateInput;\n    original: CmsGroup;\n    group: CmsGroup;\n    error: Error;\n}\n\n/**\n * GroupBeforeUpdateEvent - Published before updating a group\n */\nexport class GroupBeforeUpdateEvent extends DomainEvent<GroupBeforeUpdateEventPayload> {\n    eventType = \"Cms/Group/BeforeUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return GroupBeforeUpdateEventHandler;\n    }\n}\n\n/** Hook into group lifecycle before a group is updated. */\nexport const GroupBeforeUpdateEventHandler = createAbstraction<\n    IEventHandler<GroupBeforeUpdateEvent>\n>(\"GroupBeforeUpdateEventHandler\");\n\nexport namespace GroupBeforeUpdateEventHandler {\n    export type Interface = IEventHandler<GroupBeforeUpdateEvent>;\n    export type Event = GroupBeforeUpdateEvent;\n}\n\n/**\n * GroupAfterUpdateEvent - Published after updating a group\n */\nexport class GroupAfterUpdateEvent extends DomainEvent<GroupAfterUpdateEventPayload> {\n    eventType = \"Cms/Group/AfterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return GroupAfterUpdateEventHandler;\n    }\n}\n\n/** Hook into group lifecycle after a group is updated. */\nexport const GroupAfterUpdateEventHandler = createAbstraction<IEventHandler<GroupAfterUpdateEvent>>(\n    \"GroupAfterUpdateEventHandler\"\n);\n\nexport namespace GroupAfterUpdateEventHandler {\n    export type Interface = IEventHandler<GroupAfterUpdateEvent>;\n    export type Event = GroupAfterUpdateEvent;\n}\n\n/**\n * GroupUpdateErrorEvent - Published when update fails\n */\nexport class GroupUpdateErrorEvent extends DomainEvent<GroupUpdateErrorEventPayload> {\n    eventType = \"Cms/Group/UpdateError\" as const;\n\n    getHandlerAbstraction() {\n        return GroupUpdateErrorEventHandler;\n    }\n}\n\nexport const GroupUpdateErrorEventHandler = createAbstraction<IEventHandler<GroupUpdateErrorEvent>>(\n    \"GroupUpdateErrorEventHandler\"\n);\n\nexport namespace GroupUpdateErrorEventHandler {\n    export type Interface = IEventHandler<GroupUpdateErrorEvent>;\n    export type Event = GroupUpdateErrorEvent;\n}\n"],"names":["GroupBeforeUpdateEvent","DomainEvent","GroupBeforeUpdateEventHandler","createAbstraction","GroupAfterUpdateEvent","GroupAfterUpdateEventHandler","GroupUpdateErrorEvent","GroupUpdateErrorEventHandler"],"mappings":";;AA4BO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,gCAAgCC,kBAE3C;AAUK,MAAMC,8BAA8BH;IAGvC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMA,+BAA+BF,kBACxC;AAWG,MAAMG,8BAA8BL;IAGvC,wBAAwB;QACpB,OAAOM;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,+BAA+BJ,kBACxC"}

package/features/contentModelGroup/UpdateGroup/feature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * UpdateGroup Feature
+ *
+ * Provides functionality for updating existing content model groups.
+ * Prevents updates to plugin-based groups.
+ */
+export declare const UpdateGroupFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/contentModelGroup/UpdateGroup/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateGroupUseCase } from "./UpdateGroupUseCase.js";
+import { UpdateGroupRepository } from "./UpdateGroupRepository.js";
+const UpdateGroupFeature = createFeature({
+    name: "UpdateGroup",
+    register (container) {
+        container.register(UpdateGroupUseCase);
+        container.register(UpdateGroupRepository).inSingletonScope();
+    }
+});
+export { UpdateGroupFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/contentModelGroup/UpdateGroup/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModelGroup/UpdateGroup/feature.js","sources":["../../../../src/features/contentModelGroup/UpdateGroup/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateGroupUseCase } from \"./UpdateGroupUseCase.js\";\nimport { UpdateGroupRepository } from \"./UpdateGroupRepository.js\";\n\n/**\n * UpdateGroup Feature\n *\n * Provides functionality for updating existing content model groups.\n * Prevents updates to plugin-based groups.\n */\nexport const UpdateGroupFeature = createFeature({\n    name: \"UpdateGroup\",\n    register(container) {\n        // Register use case in transient scope (new instance per request)\n        container.register(UpdateGroupUseCase);\n\n        // Register repository in singleton scope (shared instance)\n        container.register(UpdateGroupRepository).inSingletonScope();\n    }\n});\n"],"names":["UpdateGroupFeature","createFeature","container","UpdateGroupUseCase","UpdateGroupRepository"],"mappings":";;;AAUO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;IAC9D;AACJ"}

package/features/contentModelGroup/UpdateGroup/index.d.ts

@@ -0,0 +1,2 @@
+export { UpdateGroupRepository, UpdateGroupUseCase } from "./abstractions.js";
+export { GroupAfterUpdateEventHandler, GroupBeforeUpdateEventHandler } from "./events.js";

package/features/contentModelGroup/UpdateGroup/index.js

@@ -0,0 +1,2 @@
+export { UpdateGroupRepository, UpdateGroupUseCase } from "./abstractions.js";
+export { GroupAfterUpdateEventHandler, GroupBeforeUpdateEventHandler } from "./events.js";

package/features/contentModelGroup/shared/PluginGroupsProvider.d.ts

@@ -0,0 +1,27 @@
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { AccessControl } from "../../../features/shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ModelGroupFactory, PluginGroupsProvider as ProviderAbstraction } from "./abstractions.js";
+import type { CmsGroupPlugin } from "../../../plugins/CmsGroupPlugin.js";
+import type { CmsGroup } from "../../../types/index.js";
+/**
+ * PluginGroupsProvider implementation
+ *
+ * Fetches groups from CmsGroupPlugin instances.
+ * Filters by tenant and applies access control.
+ * Results are cached based on tenant + identity + plugin signatures.
+ */
+declare class PluginGroupsProviderImpl implements ProviderAbstraction.Interface {
+    private tenantContext;
+    private pluginGroups;
+    private accessControl;
+    private identityContext;
+    private groupFactories;
+    private cache;
+    constructor(tenantContext: TenantContext.Interface, pluginGroups: CmsGroupPlugin[], accessControl: AccessControl.Interface, identityContext: IdentityContext.Interface, groupFactories: ModelGroupFactory.Interface[]);
+    getGroups(): Promise<CmsGroup[]>;
+}
+export declare const PluginGroupsProvider: typeof PluginGroupsProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IPluginGroupsProvider>;
+};
+export {};

package/features/contentModelGroup/shared/PluginGroupsProvider.js

@@ -0,0 +1,74 @@
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { AccessControl } from "../../shared/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { CmsGroupPluginInstance, ModelGroupFactory, PluginGroupsProvider } from "./abstractions.js";
+import { filterAsync } from "../../../utils/filterAsync.js";
+import { createCacheKey, createMemoryCache } from "../../../utils/index.js";
+class PluginGroupsProviderImpl {
+    constructor(tenantContext, pluginGroups, accessControl, identityContext, groupFactories){
+        this.tenantContext = tenantContext;
+        this.pluginGroups = pluginGroups;
+        this.accessControl = accessControl;
+        this.identityContext = identityContext;
+        this.groupFactories = groupFactories;
+        this.cache = createMemoryCache();
+    }
+    async getGroups() {
+        const tenant = this.tenantContext.getTenant();
+        const pluginGroups = this.pluginGroups;
+        const cacheKey = createCacheKey({
+            tenant: tenant.id,
+            identity: this.identityContext.isAuthorizationEnabled() ? this.identityContext.getIdentity()?.id : void 0,
+            groups: pluginGroups.map(({ contentModelGroup: group })=>`${group.id}#${group.slug}#${group.savedOn || "unknown"}`).join("/"),
+            codeGroups: this.groupFactories.length
+        });
+        return this.cache.getOrSet(cacheKey, async ()=>{
+            const codeGroups = await Promise.all(this.groupFactories.map((factory)=>factory.execute())).then((result)=>result.flat().map((group)=>({
+                        ...group,
+                        id: group.slug,
+                        tenant: tenant.id,
+                        description: ""
+                    })));
+            const groups = pluginGroups.filter((plugin)=>{
+                const { tenant: t } = plugin.contentModelGroup;
+                if (t && t !== tenant.id) return false;
+                return true;
+            }).map((plugin)=>({
+                    ...plugin.contentModelGroup,
+                    tenant: tenant.id
+                }));
+            return filterAsync([
+                ...codeGroups,
+                ...groups
+            ], async (group)=>{
+                if (!group) return false;
+                return this.accessControl.canAccessGroup({
+                    group
+                });
+            });
+        });
+    }
+}
+const PluginGroupsProvider_PluginGroupsProvider = PluginGroupsProvider.createImplementation({
+    implementation: PluginGroupsProviderImpl,
+    dependencies: [
+        TenantContext,
+        [
+            CmsGroupPluginInstance,
+            {
+                multiple: true
+            }
+        ],
+        AccessControl,
+        IdentityContext,
+        [
+            ModelGroupFactory,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { PluginGroupsProvider_PluginGroupsProvider as PluginGroupsProvider };
+
+//# sourceMappingURL=PluginGroupsProvider.js.map

package/features/contentModelGroup/shared/PluginGroupsProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModelGroup/shared/PluginGroupsProvider.js","sources":["../../../../src/features/contentModelGroup/shared/PluginGroupsProvider.ts"],"sourcesContent":["import { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { AccessControl } from \"~/features/shared/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport {\n    CmsGroupPluginInstance,\n    ModelGroupFactory,\n    PluginGroupsProvider as ProviderAbstraction\n} from \"./abstractions.js\";\nimport type { CmsGroupPlugin } from \"~/plugins/CmsGroupPlugin.js\";\nimport { filterAsync } from \"~/utils/filterAsync.js\";\nimport { createCacheKey } from \"~/utils/index.js\";\nimport { createMemoryCache } from \"~/utils/index.js\";\nimport type { CmsGroup } from \"~/types/index.js\";\n\n/**\n * PluginGroupsProvider implementation\n *\n * Fetches groups from CmsGroupPlugin instances.\n * Filters by tenant and applies access control.\n * Results are cached based on tenant + identity + plugin signatures.\n */\nclass PluginGroupsProviderImpl implements ProviderAbstraction.Interface {\n    private cache = createMemoryCache<Promise<CmsGroup[]>>();\n\n    public constructor(\n        private tenantContext: TenantContext.Interface,\n        private pluginGroups: CmsGroupPlugin[],\n        private accessControl: AccessControl.Interface,\n        private identityContext: IdentityContext.Interface,\n        private groupFactories: ModelGroupFactory.Interface[]\n    ) {}\n\n    async getGroups(): Promise<CmsGroup[]> {\n        const tenant = this.tenantContext.getTenant();\n        const pluginGroups = this.pluginGroups;\n\n        const cacheKey = createCacheKey({\n            tenant: tenant.id,\n            identity: this.identityContext.isAuthorizationEnabled()\n                ? this.identityContext.getIdentity()?.id\n                : undefined,\n            groups: pluginGroups\n                .map(({ contentModelGroup: group }) => {\n                    return `${group.id}#${group.slug}#${group.savedOn || \"unknown\"}`;\n                })\n                .join(\"/\"),\n            codeGroups: this.groupFactories.length\n        });\n\n        return this.cache.getOrSet(cacheKey, async (): Promise<CmsGroup[]> => {\n            // TODO: once the legacy code plugins are removed, clean this up.\n            // Currently, this code makes the new group compatible with the legacy one.\n            const codeGroups: CmsGroup[] = await Promise.all(\n                this.groupFactories.map(factory => factory.execute())\n            ).then(result => {\n                return result.flat().map<CmsGroup>(group => ({\n                    ...group,\n                    id: group.slug,\n                    tenant: tenant.id,\n                    description: \"\"\n                }));\n            });\n\n            const groups = pluginGroups\n                // Filter by tenant if specified in plugin\n                // If not specified, plugin group is available for all tenants\n                .filter(plugin => {\n                    const { tenant: t } = plugin.contentModelGroup;\n                    if (t && t !== tenant.id) {\n                        return false;\n                    }\n                    return true;\n                })\n                .map(plugin => {\n                    return {\n                        ...plugin.contentModelGroup,\n                        tenant: tenant.id\n                    };\n                });\n\n            // Apply access control filtering\n            return filterAsync([...codeGroups, ...groups], async (group?: CmsGroup) => {\n                if (!group) {\n                    return false;\n                }\n                return this.accessControl.canAccessGroup({ group });\n            });\n        });\n    }\n}\n\nexport const PluginGroupsProvider = ProviderAbstraction.createImplementation({\n    implementation: PluginGroupsProviderImpl,\n    dependencies: [\n        TenantContext,\n        [CmsGroupPluginInstance, { multiple: true }],\n        AccessControl,\n        IdentityContext,\n        [ModelGroupFactory, { multiple: true }]\n    ]\n});\n"],"names":["PluginGroupsProviderImpl","tenantContext","pluginGroups","accessControl","identityContext","groupFactories","createMemoryCache","tenant","cacheKey","createCacheKey","undefined","group","codeGroups","Promise","factory","result","groups","plugin","t","filterAsync","PluginGroupsProvider","ProviderAbstraction","TenantContext","CmsGroupPluginInstance","AccessControl","IdentityContext","ModelGroupFactory"],"mappings":";;;;;;AAqBA,MAAMA;IAGF,YACYC,aAAsC,EACtCC,YAA8B,EAC9BC,aAAsC,EACtCC,eAA0C,EAC1CC,cAA6C,CACvD;aALUJ,aAAa,GAAbA;aACAC,YAAY,GAAZA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;aACAC,cAAc,GAAdA;aAPJ,KAAK,GAAGC;IAQb;IAEH,MAAM,YAAiC;QACnC,MAAMC,SAAS,IAAI,CAAC,aAAa,CAAC,SAAS;QAC3C,MAAML,eAAe,IAAI,CAAC,YAAY;QAEtC,MAAMM,WAAWC,eAAe;YAC5B,QAAQF,OAAO,EAAE;YACjB,UAAU,IAAI,CAAC,eAAe,CAAC,sBAAsB,KAC/C,IAAI,CAAC,eAAe,CAAC,WAAW,IAAI,KACpCG;YACN,QAAQR,aACH,GAAG,CAAC,CAAC,EAAE,mBAAmBS,KAAK,EAAE,GACvB,GAAGA,MAAM,EAAE,CAAC,CAAC,EAAEA,MAAM,IAAI,CAAC,CAAC,EAAEA,MAAM,OAAO,IAAI,WAAW,EAEnE,IAAI,CAAC;YACV,YAAY,IAAI,CAAC,cAAc,CAAC,MAAM;QAC1C;QAEA,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAACH,UAAU;YAGjC,MAAMI,aAAyB,MAAMC,QAAQ,GAAG,CAC5C,IAAI,CAAC,cAAc,CAAC,GAAG,CAACC,CAAAA,UAAWA,QAAQ,OAAO,KACpD,IAAI,CAACC,CAAAA,SACIA,OAAO,IAAI,GAAG,GAAG,CAAWJ,CAAAA,QAAU;wBACzC,GAAGA,KAAK;wBACR,IAAIA,MAAM,IAAI;wBACd,QAAQJ,OAAO,EAAE;wBACjB,aAAa;oBACjB;YAGJ,MAAMS,SAASd,aAGV,MAAM,CAACe,CAAAA;gBACJ,MAAM,EAAE,QAAQC,CAAC,EAAE,GAAGD,OAAO,iBAAiB;gBAC9C,IAAIC,KAAKA,MAAMX,OAAO,EAAE,EACpB,OAAO;gBAEX,OAAO;YACX,GACC,GAAG,CAACU,CAAAA,SACM;oBACH,GAAGA,OAAO,iBAAiB;oBAC3B,QAAQV,OAAO,EAAE;gBACrB;YAIR,OAAOY,YAAY;mBAAIP;mBAAeI;aAAO,EAAE,OAAOL;gBAClD,IAAI,CAACA,OACD,OAAO;gBAEX,OAAO,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;oBAAEA;gBAAM;YACrD;QACJ;IACJ;AACJ;AAEO,MAAMS,4CAAuBC,qBAAAA,oBAAwC,CAAC;IACzE,gBAAgBrB;IAChB,cAAc;QACVsB;QACA;YAACC;YAAwB;gBAAE,UAAU;YAAK;SAAE;QAC5CC;QACAC;QACA;YAACC;YAAmB;gBAAE,UAAU;YAAK;SAAE;KAC1C;AACL"}

package/features/contentModelGroup/shared/abstractions.d.ts

@@ -0,0 +1,42 @@
+import type { CmsGroup, CmsIcon } from "../../../types/index.js";
+import type { ICache } from "../../../utils/caching/types.js";
+import type { CmsGroupPlugin } from "../../../plugins/CmsGroupPlugin.js";
+/**
+ * Multi-instance DI token holding the code-defined CmsGroupPlugin instances
+ * (previously read from the plugins container via byType). PluginGroupsProvider
+ * resolves all of these to expose plugin-defined groups.
+ */
+export declare const CmsGroupPluginInstance: import("@webiny/di").Abstraction<CmsGroupPlugin>;
+export declare namespace CmsGroupPluginInstance {
+    type Interface = CmsGroupPlugin;
+}
+/**
+ * PluginGroupsProvider provides access to plugin-defined (code) groups.
+ */
+export interface IPluginGroupsProvider {
+    getGroups(): Promise<CmsGroup[]>;
+}
+export declare const PluginGroupsProvider: import("@webiny/di").Abstraction<IPluginGroupsProvider>;
+export declare namespace PluginGroupsProvider {
+    type Interface = IPluginGroupsProvider;
+}
+export declare const GroupCache: import("@webiny/di").Abstraction<ICache<Promise<CmsGroup[]>>>;
+export declare namespace GroupCache {
+    type Interface = ICache;
+}
+interface IModelGroup {
+    slug: string;
+    name: string;
+    icon: CmsIcon;
+}
+export interface IModelGroupFactory {
+    execute(): Promise<IModelGroup[]>;
+}
+/** Provide code-defined content model groups. */
+export declare const ModelGroupFactory: import("@webiny/di").Abstraction<IModelGroupFactory>;
+export declare namespace ModelGroupFactory {
+    type Interface = IModelGroupFactory;
+    type Return = Promise<IModelGroup[]>;
+    type Group = IModelGroup;
+}
+export {};

package/features/contentModelGroup/shared/abstractions.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CmsGroupPluginInstance = createAbstraction("CmsGroupPluginInstance");
+const PluginGroupsProvider = createAbstraction("PluginGroupsProvider");
+const GroupCache = createAbstraction("GroupCache");
+const ModelGroupFactory = createAbstraction("ModelGroupFactory");
+export { CmsGroupPluginInstance, GroupCache, ModelGroupFactory, PluginGroupsProvider };
+
+//# sourceMappingURL=abstractions.js.map

package/features/contentModelGroup/shared/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/contentModelGroup/shared/abstractions.js","sources":["../../../../src/features/contentModelGroup/shared/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsGroup, CmsIcon } from \"~/types/index.js\";\nimport type { ICache } from \"~/utils/caching/types.js\";\nimport type { CmsGroupPlugin } from \"~/plugins/CmsGroupPlugin.js\";\n\n/**\n * Multi-instance DI token holding the code-defined CmsGroupPlugin instances\n * (previously read from the plugins container via byType). PluginGroupsProvider\n * resolves all of these to expose plugin-defined groups.\n */\nexport const CmsGroupPluginInstance = createAbstraction<CmsGroupPlugin>(\"CmsGroupPluginInstance\");\n\nexport namespace CmsGroupPluginInstance {\n    export type Interface = CmsGroupPlugin;\n}\n\n/**\n * PluginGroupsProvider provides access to plugin-defined (code) groups.\n */\nexport interface IPluginGroupsProvider {\n    getGroups(): Promise<CmsGroup[]>;\n}\n\nexport const PluginGroupsProvider =\n    createAbstraction<IPluginGroupsProvider>(\"PluginGroupsProvider\");\n\nexport namespace PluginGroupsProvider {\n    export type Interface = IPluginGroupsProvider;\n}\n\nexport const GroupCache = createAbstraction<ICache<Promise<CmsGroup[]>>>(\"GroupCache\");\n\nexport namespace GroupCache {\n    export type Interface = ICache;\n}\n\ninterface IModelGroup {\n    slug: string;\n    name: string;\n    icon: CmsIcon;\n}\n\nexport interface IModelGroupFactory {\n    execute(): Promise<IModelGroup[]>;\n}\n\n/** Provide code-defined content model groups. */\nexport const ModelGroupFactory = createAbstraction<IModelGroupFactory>(\"ModelGroupFactory\");\nexport namespace ModelGroupFactory {\n    export type Interface = IModelGroupFactory;\n    export type Return = Promise<IModelGroup[]>;\n    export type Group = IModelGroup;\n}\n"],"names":["CmsGroupPluginInstance","createAbstraction","PluginGroupsProvider","GroupCache","ModelGroupFactory"],"mappings":";AAUO,MAAMA,yBAAyBC,kBAAkC;AAajE,MAAMC,uBACTD,kBAAyC;AAMtC,MAAME,aAAaF,kBAA+C;AAiBlE,MAAMG,oBAAoBH,kBAAsC"}

package/features/contentModelGroup/shared/index.d.ts

@@ -0,0 +1 @@
+export { ModelGroupFactory, GroupCache, PluginGroupsProvider } from "./abstractions.js";

package/features/contentModelGroup/shared/index.js

@@ -0,0 +1 @@
+export { GroupCache, ModelGroupFactory, PluginGroupsProvider } from "./abstractions.js";

package/features/graphql/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const GraphQLFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/graphql/feature.js

@@ -0,0 +1,37 @@
+import { createFeature } from "@webiny/feature/api";
+import { CmsModelFieldToGraphQLRegistry } from "./fields/CmsModelFieldToGraphQLRegistry.js";
+import { BooleanFieldToGraphQL } from "./fields/base/BooleanToGraphQL.js";
+import { DateTimeFieldToGraphQL } from "./fields/base/DateTimeToGraphQL.js";
+import { DynamicZoneFieldToGraphQL } from "./fields/base/DynamicZoneToGraphQL.js";
+import { FileFieldToGraphQL } from "./fields/base/FileToGraphQL.js";
+import { JsonFieldToGraphQL } from "./fields/base/JsonToGraphQL.js";
+import { LongTextFieldToGraphQL } from "./fields/base/LongTextToGraphQL.js";
+import { NumberFieldToGraphQL } from "./fields/base/NumberToGraphQL.js";
+import { ObjectFieldToGraphQL } from "./fields/base/ObjectToGraphQL.js";
+import { RefFieldToGraphQL } from "./fields/base/RefToGraphQL.js";
+import { SearchableJsonFieldToGraphQL } from "./fields/base/SearchableJsonToGraphQL.js";
+import { TextFieldToGraphQL } from "./fields/base/TextToGraphQL.js";
+import { RichTextFieldToGraphQL } from "./fields/base/RichTextToGraphQL.js";
+import { AssetFieldToGraphQL } from "./fields/base/AssetToGraphQL.js";
+const GraphQLFeature = createFeature({
+    name: "Cms/GraphQLFeature",
+    register: (container)=>{
+        container.register(BooleanFieldToGraphQL);
+        container.register(DateTimeFieldToGraphQL);
+        container.register(DynamicZoneFieldToGraphQL);
+        container.register(FileFieldToGraphQL);
+        container.register(JsonFieldToGraphQL);
+        container.register(LongTextFieldToGraphQL);
+        container.register(NumberFieldToGraphQL);
+        container.register(ObjectFieldToGraphQL);
+        container.register(RefFieldToGraphQL);
+        container.register(RichTextFieldToGraphQL);
+        container.register(SearchableJsonFieldToGraphQL);
+        container.register(TextFieldToGraphQL);
+        container.register(AssetFieldToGraphQL);
+        container.register(CmsModelFieldToGraphQLRegistry).inSingletonScope();
+    }
+});
+export { GraphQLFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/graphql/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/graphql/feature.js","sources":["../../../src/features/graphql/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CmsModelFieldToGraphQLRegistry } from \"./fields/CmsModelFieldToGraphQLRegistry.js\";\nimport { BooleanFieldToGraphQL } from \"./fields/base/BooleanToGraphQL.js\";\nimport { DateTimeFieldToGraphQL } from \"./fields/base/DateTimeToGraphQL.js\";\nimport { DynamicZoneFieldToGraphQL } from \"./fields/base/DynamicZoneToGraphQL.js\";\nimport { FileFieldToGraphQL } from \"./fields/base/FileToGraphQL.js\";\nimport { JsonFieldToGraphQL } from \"./fields/base/JsonToGraphQL.js\";\nimport { LongTextFieldToGraphQL } from \"./fields/base/LongTextToGraphQL.js\";\nimport { NumberFieldToGraphQL } from \"./fields/base/NumberToGraphQL.js\";\nimport { ObjectFieldToGraphQL } from \"./fields/base/ObjectToGraphQL.js\";\nimport { RefFieldToGraphQL } from \"./fields/base/RefToGraphQL.js\";\nimport { SearchableJsonFieldToGraphQL } from \"./fields/base/SearchableJsonToGraphQL.js\";\nimport { TextFieldToGraphQL } from \"./fields/base/TextToGraphQL.js\";\nimport { RichTextFieldToGraphQL } from \"./fields/base/RichTextToGraphQL.js\";\nimport { AssetFieldToGraphQL } from \"./fields/base/AssetToGraphQL.js\";\n\nexport const GraphQLFeature = createFeature({\n    name: \"Cms/GraphQLFeature\",\n    register: container => {\n        container.register(BooleanFieldToGraphQL);\n        container.register(DateTimeFieldToGraphQL);\n        container.register(DynamicZoneFieldToGraphQL);\n        container.register(FileFieldToGraphQL);\n        container.register(JsonFieldToGraphQL);\n        container.register(LongTextFieldToGraphQL);\n        container.register(NumberFieldToGraphQL);\n        container.register(ObjectFieldToGraphQL);\n        container.register(RefFieldToGraphQL);\n        container.register(RichTextFieldToGraphQL);\n        container.register(SearchableJsonFieldToGraphQL);\n        container.register(TextFieldToGraphQL);\n        container.register(AssetFieldToGraphQL);\n\n        container.register(CmsModelFieldToGraphQLRegistry).inSingletonScope();\n    }\n});\n"],"names":["GraphQLFeature","createFeature","container","BooleanFieldToGraphQL","DateTimeFieldToGraphQL","DynamicZoneFieldToGraphQL","FileFieldToGraphQL","JsonFieldToGraphQL","LongTextFieldToGraphQL","NumberFieldToGraphQL","ObjectFieldToGraphQL","RefFieldToGraphQL","RichTextFieldToGraphQL","SearchableJsonFieldToGraphQL","TextFieldToGraphQL","AssetFieldToGraphQL","CmsModelFieldToGraphQLRegistry"],"mappings":";;;;;;;;;;;;;;;AAgBO,MAAMA,iBAAiBC,cAAc;IACxC,MAAM;IACN,UAAUC,CAAAA;QACNA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,QAAQ,CAACS;QACnBT,UAAU,QAAQ,CAACU;QACnBV,UAAU,QAAQ,CAACW;QACnBX,UAAU,QAAQ,CAACY;QACnBZ,UAAU,QAAQ,CAACa;QAEnBb,UAAU,QAAQ,CAACc,gCAAgC,gBAAgB;IACvE;AACJ"}

package/features/graphql/fields/CmsModelFieldToGraphQLRegistry.d.ts

@@ -0,0 +1,13 @@
+import { CmsModelFieldToGraphQLRegistry as CmsModelFieldToGraphQLRegistryAbstraction } from "./abstractions/CmsModelFieldToGraphQLRegistry.js";
+import { CmsModelFieldToGraphQL } from "./abstractions/CmsModelFieldToGraphQL.js";
+import type { CmsModelFieldType } from "../../../types/modelField.js";
+declare class CmsModelFieldToGraphQLRegistryImpl implements CmsModelFieldToGraphQLRegistryAbstraction.Interface {
+    private readonly fields;
+    constructor(fields: CmsModelFieldToGraphQL.Interface[]);
+    get(type: CmsModelFieldType): CmsModelFieldToGraphQL.Interface | undefined;
+    getAll(): CmsModelFieldToGraphQL.Interface[];
+}
+export declare const CmsModelFieldToGraphQLRegistry: typeof CmsModelFieldToGraphQLRegistryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions/CmsModelFieldToGraphQLRegistry.js").ICmsModelFieldToGraphQLRegistry>;
+};
+export {};

package/features/graphql/fields/CmsModelFieldToGraphQLRegistry.js

@@ -0,0 +1,31 @@
+import { CmsModelFieldToGraphQLRegistry } from "./abstractions/CmsModelFieldToGraphQLRegistry.js";
+import { CmsModelFieldToGraphQL } from "./abstractions/CmsModelFieldToGraphQL.js";
+import { getBaseFieldType } from "../../../utils/getBaseFieldType.js";
+class CmsModelFieldToGraphQLRegistryImpl {
+    constructor(fields){
+        this.fields = fields;
+    }
+    get(type) {
+        const fieldType = getBaseFieldType({
+            type
+        });
+        return this.fields.find((field)=>field.fieldType === fieldType);
+    }
+    getAll() {
+        return this.fields;
+    }
+}
+const CmsModelFieldToGraphQLRegistry_CmsModelFieldToGraphQLRegistry = CmsModelFieldToGraphQLRegistry.createImplementation({
+    implementation: CmsModelFieldToGraphQLRegistryImpl,
+    dependencies: [
+        [
+            CmsModelFieldToGraphQL,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { CmsModelFieldToGraphQLRegistry_CmsModelFieldToGraphQLRegistry as CmsModelFieldToGraphQLRegistry };
+
+//# sourceMappingURL=CmsModelFieldToGraphQLRegistry.js.map

package/features/graphql/fields/CmsModelFieldToGraphQLRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/graphql/fields/CmsModelFieldToGraphQLRegistry.js","sources":["../../../../src/features/graphql/fields/CmsModelFieldToGraphQLRegistry.ts"],"sourcesContent":["import { CmsModelFieldToGraphQLRegistry as CmsModelFieldToGraphQLRegistryAbstraction } from \"./abstractions/CmsModelFieldToGraphQLRegistry.js\";\nimport { CmsModelFieldToGraphQL } from \"./abstractions/CmsModelFieldToGraphQL.js\";\nimport type { CmsModelFieldType } from \"~/types/modelField.js\";\nimport { getBaseFieldType } from \"~/utils/getBaseFieldType.js\";\n\nclass CmsModelFieldToGraphQLRegistryImpl\n    implements CmsModelFieldToGraphQLRegistryAbstraction.Interface\n{\n    public constructor(private readonly fields: CmsModelFieldToGraphQL.Interface[]) {}\n\n    public get(type: CmsModelFieldType): CmsModelFieldToGraphQL.Interface | undefined {\n        const fieldType = getBaseFieldType({\n            type\n        });\n        return this.fields.find(field => {\n            return field.fieldType === fieldType;\n        });\n    }\n\n    public getAll(): CmsModelFieldToGraphQL.Interface[] {\n        return this.fields;\n    }\n}\n\nexport const CmsModelFieldToGraphQLRegistry =\n    CmsModelFieldToGraphQLRegistryAbstraction.createImplementation({\n        implementation: CmsModelFieldToGraphQLRegistryImpl,\n        dependencies: [[CmsModelFieldToGraphQL, { multiple: true }]]\n    });\n"],"names":["CmsModelFieldToGraphQLRegistryImpl","fields","type","fieldType","getBaseFieldType","field","CmsModelFieldToGraphQLRegistry","CmsModelFieldToGraphQLRegistryAbstraction","CmsModelFieldToGraphQL"],"mappings":";;;AAKA,MAAMA;IAGF,YAAoCC,MAA0C,CAAE;aAA5CA,MAAM,GAANA;IAA6C;IAE1E,IAAIC,IAAuB,EAAgD;QAC9E,MAAMC,YAAYC,iBAAiB;YAC/BF;QACJ;QACA,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAACG,CAAAA,QACbA,MAAM,SAAS,KAAKF;IAEnC;IAEO,SAA6C;QAChD,OAAO,IAAI,CAAC,MAAM;IACtB;AACJ;AAEO,MAAMG,gEACTC,+BAAAA,oBAA8D,CAAC;IAC3D,gBAAgBP;IAChB,cAAc;QAAC;YAACQ;YAAwB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAChE"}

package/features/graphql/fields/abstractions/CmsModelFieldToGraphQL.d.ts

@@ -0,0 +1,97 @@
+import type { GraphQLFieldResolver, Resolvers } from "@webiny/api-graphql/types.js";
+import type { GraphQLSchemaDefinition } from "@webiny/api-graphql/types.js";
+import type { CmsModelField, CmsModelFieldType } from "../../../../types/modelField.js";
+import type { CmsModel } from "../../../../types/model.js";
+import type { CmsModelFieldDefinition } from "../../../../types/types.js";
+import type { CmsContext } from "../../../../types/types.js";
+export interface ValidateChildFieldsValidateParams<TField extends CmsModelField = CmsModelField> {
+    fields: TField[];
+    originalFields: TField[];
+}
+export interface ValidateChildFieldsValidate {
+    (params: ValidateChildFieldsValidateParams): void;
+}
+export interface ValidateChildFieldsParams<TField extends CmsModelField = CmsModelField> {
+    field: TField;
+    originalField?: TField;
+    validate: ValidateChildFieldsValidate;
+}
+export interface ValidateChildFields<TField extends CmsModelField = CmsModelField> {
+    (params: ValidateChildFieldsParams<TField>): void;
+}
+import type { GenericRecord } from "@webiny/api/types.js";
+import type { GetCmsModelFieldAst } from "../../../../types/modelAst.js";
+import type { CmsModelFieldToGraphQLRegistry } from "./CmsModelFieldToGraphQLRegistry.js";
+export interface CreateTypeFieldParams<TField extends CmsModelField = CmsModelField> {
+    models: CmsModel[];
+    model: CmsModel;
+    field: TField;
+    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;
+}
+export interface CreateGetFiltersParams<TField extends CmsModelField = CmsModelField> {
+    field: TField;
+}
+export interface CreateListFiltersParams<TField extends CmsModelField = CmsModelField> {
+    model: Pick<CmsModel, "singularApiName">;
+    field: TField;
+    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;
+}
+export interface CreateResolverParams<TField extends CmsModelField = CmsModelField> {
+    models: CmsModel[];
+    model: CmsModel;
+    graphQLType: string;
+    field: TField;
+    createFieldResolvers: any;
+    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;
+}
+export type ResolverResult = GraphQLFieldResolver | {
+    resolver: GraphQLFieldResolver | null;
+    typeResolvers: Resolvers<CmsContext>;
+} | false;
+export interface CreateSchemaParams {
+    models: CmsModel[];
+}
+export interface NormalizeInputParams<TField extends CmsModelField = CmsModelField> {
+    model: CmsModel;
+    field: TField;
+    input: GenericRecord<string> | Array<GenericRecord<string>>;
+}
+export interface ICmsFieldReadApi<TField extends CmsModelField = CmsModelField> {
+    createTypeField(params: CreateTypeFieldParams<TField>): CmsModelFieldDefinition | string | null;
+    createGetFilters?(params: CreateGetFiltersParams<TField>): string;
+    createListFilters?(params: CreateListFiltersParams<TField>): string;
+    createResolver?(params: CreateResolverParams<TField>): ResolverResult;
+    createSchema?(params: CreateSchemaParams): GraphQLSchemaDefinition<CmsContext>;
+}
+export interface ICmsFieldManageApi<TField extends CmsModelField = CmsModelField> extends ICmsFieldReadApi<TField> {
+    createInputField(params: CreateTypeFieldParams<TField>): CmsModelFieldDefinition | string | null;
+    normalizeInput?<T>(params: NormalizeInputParams<TField>): Promise<T>;
+}
+export interface ICmsModelFieldToGraphQL<TField extends CmsModelField = CmsModelField> {
+    readonly fieldType: CmsModelFieldType;
+    readonly isSearchable: boolean;
+    readonly isSortable: boolean;
+    readonly isFullTextSearchable: boolean;
+    readonly read: ICmsFieldReadApi<TField>;
+    readonly manage: ICmsFieldManageApi<TField>;
+    getReadApi(): ICmsFieldReadApi<TField>;
+    getManageApi(): ICmsFieldManageApi<TField>;
+    validateChildFields?: ValidateChildFields<TField>;
+    getFieldAst?: GetCmsModelFieldAst<TField>;
+}
+export declare const CmsModelFieldToGraphQL: import("@webiny/di").Abstraction<ICmsModelFieldToGraphQL<CmsModelField>>;
+export declare namespace CmsModelFieldToGraphQL {
+    type Interface = ICmsModelFieldToGraphQL;
+    type ReadApi<TField extends CmsModelField = CmsModelField> = ICmsFieldReadApi<TField>;
+    type ManageApi<TField extends CmsModelField = CmsModelField> = ICmsFieldManageApi<TField>;
+    type TypeFieldParams<TField extends CmsModelField = CmsModelField> = CreateTypeFieldParams<TField>;
+    type GetFiltersParams<TField extends CmsModelField = CmsModelField> = CreateGetFiltersParams<TField>;
+    type ListFiltersParams<TField extends CmsModelField = CmsModelField> = CreateListFiltersParams<TField>;
+    type ResolverParams<TField extends CmsModelField = CmsModelField> = CreateResolverParams<TField>;
+    type SchemaParams = CreateSchemaParams;
+    type InputNormalizeParams<TField extends CmsModelField = CmsModelField> = NormalizeInputParams<TField>;
+    type Resolver = ResolverResult;
+    type ChildFieldsValidateParams<TField extends CmsModelField = CmsModelField> = ValidateChildFieldsParams<TField>;
+    type ChildFieldsValidate<TField extends CmsModelField = CmsModelField> = ValidateChildFields<TField>;
+    type ChildFieldsValidateValidate = ValidateChildFieldsValidate;
+}

package/features/graphql/fields/abstractions/CmsModelFieldToGraphQL.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CmsModelFieldToGraphQL = createAbstraction("Cms/GraphQL/Schema/ModelField");
+export { CmsModelFieldToGraphQL };
+
+//# sourceMappingURL=CmsModelFieldToGraphQL.js.map

package/features/graphql/fields/abstractions/CmsModelFieldToGraphQL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/graphql/fields/abstractions/CmsModelFieldToGraphQL.js","sources":["../../../../../src/features/graphql/fields/abstractions/CmsModelFieldToGraphQL.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GraphQLFieldResolver, Resolvers } from \"@webiny/api-graphql/types.js\";\nimport type { GraphQLSchemaDefinition } from \"@webiny/api-graphql/types.js\";\nimport type { CmsModelField, CmsModelFieldType } from \"~/types/modelField.js\";\nimport type { CmsModel } from \"~/types/model.js\";\nimport type { CmsModelFieldDefinition } from \"~/types/types.js\";\nimport type { CmsContext } from \"~/types/types.js\";\n\nexport interface ValidateChildFieldsValidateParams<TField extends CmsModelField = CmsModelField> {\n    fields: TField[];\n    originalFields: TField[];\n}\n\nexport interface ValidateChildFieldsValidate {\n    (params: ValidateChildFieldsValidateParams): void;\n}\n\nexport interface ValidateChildFieldsParams<TField extends CmsModelField = CmsModelField> {\n    field: TField;\n    originalField?: TField;\n    validate: ValidateChildFieldsValidate;\n}\n\nexport interface ValidateChildFields<TField extends CmsModelField = CmsModelField> {\n    (params: ValidateChildFieldsParams<TField>): void;\n}\nimport type { GenericRecord } from \"@webiny/api/types.js\";\nimport type { GetCmsModelFieldAst } from \"~/types/modelAst.js\";\nimport type { CmsModelFieldToGraphQLRegistry } from \"./CmsModelFieldToGraphQLRegistry.js\";\n\nexport interface CreateTypeFieldParams<TField extends CmsModelField = CmsModelField> {\n    models: CmsModel[];\n    model: CmsModel;\n    field: TField;\n    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\n}\n\nexport interface CreateGetFiltersParams<TField extends CmsModelField = CmsModelField> {\n    field: TField;\n}\n\nexport interface CreateListFiltersParams<TField extends CmsModelField = CmsModelField> {\n    model: Pick<CmsModel, \"singularApiName\">;\n    field: TField;\n    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\n}\n\nexport interface CreateResolverParams<TField extends CmsModelField = CmsModelField> {\n    models: CmsModel[];\n    model: CmsModel;\n    graphQLType: string;\n    field: TField;\n    createFieldResolvers: any;\n    fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface;\n}\n\nexport type ResolverResult =\n    | GraphQLFieldResolver\n    | {\n          resolver: GraphQLFieldResolver | null;\n          typeResolvers: Resolvers<CmsContext>;\n      }\n    | false;\n\nexport interface CreateSchemaParams {\n    models: CmsModel[];\n}\n\nexport interface NormalizeInputParams<TField extends CmsModelField = CmsModelField> {\n    model: CmsModel;\n    field: TField;\n    input: GenericRecord<string> | Array<GenericRecord<string>>;\n}\n\nexport interface ICmsFieldReadApi<TField extends CmsModelField = CmsModelField> {\n    createTypeField(params: CreateTypeFieldParams<TField>): CmsModelFieldDefinition | string | null;\n    createGetFilters?(params: CreateGetFiltersParams<TField>): string;\n    createListFilters?(params: CreateListFiltersParams<TField>): string;\n    createResolver?(params: CreateResolverParams<TField>): ResolverResult;\n    createSchema?(params: CreateSchemaParams): GraphQLSchemaDefinition<CmsContext>;\n}\n\nexport interface ICmsFieldManageApi<\n    TField extends CmsModelField = CmsModelField\n> extends ICmsFieldReadApi<TField> {\n    createInputField(\n        params: CreateTypeFieldParams<TField>\n    ): CmsModelFieldDefinition | string | null;\n    normalizeInput?<T>(params: NormalizeInputParams<TField>): Promise<T>;\n}\n\nexport interface ICmsModelFieldToGraphQL<TField extends CmsModelField = CmsModelField> {\n    /* Metadata. */\n    readonly fieldType: CmsModelFieldType;\n    readonly isSearchable: boolean;\n    readonly isSortable: boolean;\n    readonly isFullTextSearchable: boolean;\n\n    /* API surfaces. */\n    readonly read: ICmsFieldReadApi<TField>;\n    readonly manage: ICmsFieldManageApi<TField>;\n    getReadApi(): ICmsFieldReadApi<TField>;\n    getManageApi(): ICmsFieldManageApi<TField>;\n\n    /* Validation & AST. */\n    validateChildFields?: ValidateChildFields<TField>;\n    getFieldAst?: GetCmsModelFieldAst<TField>;\n}\n\nexport const CmsModelFieldToGraphQL = createAbstraction<ICmsModelFieldToGraphQL>(\n    \"Cms/GraphQL/Schema/ModelField\"\n);\n\nexport namespace CmsModelFieldToGraphQL {\n    export type Interface = ICmsModelFieldToGraphQL;\n    export type ReadApi<TField extends CmsModelField = CmsModelField> = ICmsFieldReadApi<TField>;\n    export type ManageApi<TField extends CmsModelField = CmsModelField> =\n        ICmsFieldManageApi<TField>;\n    export type TypeFieldParams<TField extends CmsModelField = CmsModelField> =\n        CreateTypeFieldParams<TField>;\n    export type GetFiltersParams<TField extends CmsModelField = CmsModelField> =\n        CreateGetFiltersParams<TField>;\n    export type ListFiltersParams<TField extends CmsModelField = CmsModelField> =\n        CreateListFiltersParams<TField>;\n    export type ResolverParams<TField extends CmsModelField = CmsModelField> =\n        CreateResolverParams<TField>;\n    export type SchemaParams = CreateSchemaParams;\n    export type InputNormalizeParams<TField extends CmsModelField = CmsModelField> =\n        NormalizeInputParams<TField>;\n    export type Resolver = ResolverResult;\n    export type ChildFieldsValidateParams<TField extends CmsModelField = CmsModelField> =\n        ValidateChildFieldsParams<TField>;\n    export type ChildFieldsValidate<TField extends CmsModelField = CmsModelField> =\n        ValidateChildFields<TField>;\n    export type ChildFieldsValidateValidate = ValidateChildFieldsValidate;\n}\n"],"names":["CmsModelFieldToGraphQL","createAbstraction"],"mappings":";AA6GO,MAAMA,yBAAyBC,kBAClC"}

package/features/graphql/fields/abstractions/CmsModelFieldToGraphQLRegistry.d.ts

@@ -0,0 +1,10 @@
+import type { CmsModelFieldType } from "../../../../types/modelField.js";
+import type { CmsModelFieldToGraphQL } from "./CmsModelFieldToGraphQL.js";
+export interface ICmsModelFieldToGraphQLRegistry {
+    get(fieldType: CmsModelFieldType): CmsModelFieldToGraphQL.Interface | undefined;
+    getAll(): CmsModelFieldToGraphQL.Interface[];
+}
+export declare const CmsModelFieldToGraphQLRegistry: import("@webiny/di").Abstraction<ICmsModelFieldToGraphQLRegistry>;
+export declare namespace CmsModelFieldToGraphQLRegistry {
+    type Interface = ICmsModelFieldToGraphQLRegistry;
+}