@webiny/api-aco 6.6.0-alpha.0 → 6.6.0-alpha.1

package/AcoFeature.js

@@ -5,7 +5,10 @@ import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/i
 import { HeadlessCms } from "@webiny/api-headless-cms/features/shared/abstractions.js";
 import { addAcoBaseSchema } from "./createAcoGraphQL.js";
 import { addFilterSchema } from "./filter/filter.gql.js";
-import { AcoInitializer } from "./AcoInitializer.js";
+import { AcoFolderSchemaFactory } from "./AcoFolderSchemaFactory.js";
+import { FolderModelProvider } from "./features/folder/FolderModelProvider.js";
+import { CmsFlpFeature } from "./features/cms/index.js";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
 import { CreateFlpTask } from "./flp/tasks/createFlp.task.js";
 import { UpdateFlpTask } from "./flp/tasks/updateFlp.task.js";
 import { DeleteFlpTask } from "./flp/tasks/deleteFlp.task.js";
@@ -36,6 +39,7 @@ import { GetFlpFeature } from "./features/flp/GetFlp/feature.js";
 import { ListFolderLevelPermissionsTargetsFeature } from "./features/folder/ListFolderLevelPermissionsTargets/feature.js";
 import { CreateFlpOnFolderCreatedFeature } from "./features/flp/CreateFlpOnFolderCreated/index.js";
 import { EnsureFolderIsEmptyFeature } from "./features/folder/EnsureFolderIsEmpty/feature.js";
+import { AcoAiToolsFeature } from "./features/ai/index.js";
 class AcoSchemaFactoryImpl {
     async execute(builder) {
         addAcoBaseSchema(builder);
@@ -51,6 +55,7 @@ const AcoFeature = createFeature({
     name: "Aco",
     register (container) {
         container.register(FolderModel);
+        AcoAiToolsFeature.register(container);
         container.register(FilterPrivateModel);
         container.register(CreateFlpTask);
         container.register(UpdateFlpTask);
@@ -113,8 +118,10 @@ const AcoFeature = createFeature({
             });
             return filterCrudMethods;
         });
-        container.register(AcoInitializer);
+        container.register(FolderModelProvider);
+        if (container.resolve(FeatureFlags).get().isEnabled("advancedAccessControlLayer.folderLevelPermissions")) CmsFlpFeature.register(container);
         container.register(AcoSchemaFactory);
+        container.register(AcoFolderSchemaFactory);
     }
 });
 export { AcoFeature };

package/AcoFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"AcoFeature.js","sources":["../src/AcoFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GraphQLSchemaFactory } from \"@webiny/api-graphql/graphql/abstractions.js\";\nimport type { IGraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\nimport type { Container } from \"@webiny/di\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { HeadlessCms } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport { addAcoBaseSchema } from \"./createAcoGraphQL.js\";\nimport { addFilterSchema } from \"~/filter/filter.gql.js\";\nimport { AcoInitializer } from \"./AcoInitializer.js\";\nimport { CreateFlpTask } from \"~/flp/tasks/createFlp.task.js\";\nimport { UpdateFlpTask } from \"~/flp/tasks/updateFlp.task.js\";\nimport { DeleteFlpTask } from \"~/flp/tasks/deleteFlp.task.js\";\nimport { SyncFlpTask } from \"~/flp/tasks/syncFlp.task.js\";\nimport type { AcoStorageOperations } from \"~/types.js\";\nimport type { Tenant } from \"@webiny/api-core/types/tenancy.js\";\nimport { FolderModel } from \"~/domain/folder/folder.model.js\";\nimport { FilterPrivateModel } from \"~/filter/filter.model.js\";\n// Facade wiring (moved here from createAcoContext so the ACO facade can be a lazy DI factory).\nimport { createFilterOperations } from \"~/filter/filter.so.js\";\nimport { createFilterCrudMethods } from \"~/filter/filter.crud.js\";\nimport { createFlpCrudMethods } from \"~/flp/index.js\";\nimport {\n    FolderLevelPermissions,\n    FolderLevelPermissionsFeature\n} from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { UpdateFolderFeature } from \"~/features/folder/UpdateFolder/index.js\";\nimport { DeleteFolderFeature } from \"~/features/folder/DeleteFolder/index.js\";\nimport { CreateFolderFeature } from \"~/features/folder/CreateFolder/index.js\";\nimport { GetFolderFeature } from \"~/features/folder/GetFolder/index.js\";\nimport { ListFoldersFeature } from \"~/features/folder/ListFolders/index.js\";\nimport { GetFolderHierarchyFeature } from \"~/features/folder/GetFolderHierarchy/index.js\";\nimport { GetAncestorsFeature } from \"~/features/folder/GetAncestors/index.js\";\nimport { UpdateFlpOnFolderUpdatedFeature } from \"~/features/flp/UpdateFlpOnFolderUpdated/index.js\";\nimport { DeleteFlpOnFolderDeletedFeature } from \"~/features/flp/DeleteFlpOnFolderDeleted/index.js\";\nimport { EnsureHcmsFolderIsEmptyOnDeleteFeature } from \"~/features/folder/EnsureHcmsFolderIsEmptyOnDelete/index.js\";\nimport { CreateFlpFeature } from \"~/features/flp/CreateFlp/index.js\";\nimport { DeleteFlpFeature } from \"~/features/flp/DeleteFlp/index.js\";\nimport { UpdateFlpFeature } from \"~/features/flp/UpdateFlp/index.js\";\nimport { EnsureFolderIsEmptyOnDeleteFeature } from \"~/features/folder/EnsureFolderIsEmptyOnDelete/index.js\";\nimport {\n    AcoFilterCrud,\n    AcoFlpCrud,\n    FilterStorageOperations,\n    FlpStorageOperations\n} from \"~/features/folder/shared/abstractions.js\";\nimport { ListFlpsFeature } from \"~/features/flp/ListFlps/feature.js\";\nimport { GetFlpFeature } from \"~/features/flp/GetFlp/feature.js\";\nimport { ListFolderLevelPermissionsTargetsFeature } from \"~/features/folder/ListFolderLevelPermissionsTargets/feature.js\";\nimport { CreateFlpOnFolderCreatedFeature } from \"~/features/flp/CreateFlpOnFolderCreated/index.js\";\nimport { EnsureFolderIsEmptyFeature } from \"~/features/folder/EnsureFolderIsEmpty/feature.js\";\n\nclass AcoSchemaFactoryImpl implements GraphQLSchemaFactory.Interface {\n    async execute(builder: IGraphQLSchemaBuilder): Promise<IGraphQLSchemaBuilder> {\n        // Static ACO base + filter schema (DI-native contributors declaring their deps). The dynamic\n        // folder schema (needs the per-tenant folder model) is still built by AcoInitializer.\n        addAcoBaseSchema(builder);\n        addFilterSchema(builder);\n        return builder;\n    }\n}\n\nconst AcoSchemaFactory = GraphQLSchemaFactory.createImplementation({\n    implementation: AcoSchemaFactoryImpl,\n    dependencies: []\n});\n\nexport const AcoFeature = createFeature({\n    name: \"Aco\",\n    register(container: Container) {\n        container.register(FolderModel);\n        container.register(FilterPrivateModel);\n\n        // Background task definitions — pure wiring, no tenant/identity needed.\n        container.register(CreateFlpTask);\n        container.register(UpdateFlpTask);\n        container.register(DeleteFlpTask);\n        container.register(SyncFlpTask);\n\n        // Folder + FLP use-case features — pure DI wiring (all lazy). Moved out of the per-request\n        // initializer so they're registered for every event, not only GraphQL requests.\n        FolderLevelPermissionsFeature.register(container);\n        CreateFolderFeature.register(container);\n        UpdateFolderFeature.register(container);\n        DeleteFolderFeature.register(container);\n        GetFolderFeature.register(container);\n        ListFoldersFeature.register(container);\n        ListFolderLevelPermissionsTargetsFeature.register(container);\n        GetFolderHierarchyFeature.register(container);\n        GetAncestorsFeature.register(container);\n        EnsureFolderIsEmptyFeature.register(container);\n        CreateFlpFeature.register(container);\n        UpdateFlpFeature.register(container);\n        DeleteFlpFeature.register(container);\n        ListFlpsFeature.register(container);\n        GetFlpFeature.register(container);\n        CreateFlpOnFolderCreatedFeature.register(container);\n        UpdateFlpOnFolderUpdatedFeature.register(container);\n        DeleteFlpOnFolderDeletedFeature.register(container);\n        EnsureFolderIsEmptyOnDeleteFeature.register(container);\n        EnsureHcmsFolderIsEmptyOnDeleteFeature.register(container);\n\n        // ===== Lazy ACO facade =====\n        // Built on first resolve (post-auth) so the HeadlessCms facade (also lazy) is resolved on\n        // demand. Memoised per request container. Consumers resolve AcoFlpCrud / AcoFilterCrud /\n        // FilterStorageOperations via DI.\n        const getTenant = (): Tenant => container.resolve(TenantContext).getTenant();\n\n        let storageOperations: AcoStorageOperations | undefined;\n        const getStorageOperations = (): AcoStorageOperations => {\n            if (!storageOperations) {\n                const cms = container.resolve(HeadlessCms);\n                const identityContext = container.resolve(IdentityContext);\n                storageOperations = {\n                    filter: createFilterOperations({ cms, identityContext, container }),\n                    flp: container.resolve(FlpStorageOperations)\n                };\n            }\n            return storageOperations;\n        };\n\n        let flpCrudMethods: ReturnType<typeof createFlpCrudMethods> | undefined;\n        const getFlpCrudMethods = () => {\n            if (!flpCrudMethods) {\n                flpCrudMethods = createFlpCrudMethods({\n                    getTenant,\n                    storageOperations: getStorageOperations()\n                });\n            }\n            return flpCrudMethods;\n        };\n        container.registerFactory(AcoFlpCrud, () => getFlpCrudMethods());\n        container.registerFactory(FilterStorageOperations, () => getStorageOperations().filter);\n\n        let filterCrudMethods: ReturnType<typeof createFilterCrudMethods> | undefined;\n        container.registerFactory(AcoFilterCrud, () => {\n            if (!filterCrudMethods) {\n                filterCrudMethods = createFilterCrudMethods({\n                    container,\n                    getTenant,\n                    storageOperations: getStorageOperations(),\n                    folderLevelPermissions: container.resolve(FolderLevelPermissions)\n                });\n            }\n            return filterCrudMethods;\n        });\n\n        container.register(AcoInitializer);\n        container.register(AcoSchemaFactory);\n    }\n});\n"],"names":["AcoSchemaFactoryImpl","builder","addAcoBaseSchema","addFilterSchema","AcoSchemaFactory","GraphQLSchemaFactory","AcoFeature","createFeature","container","FolderModel","FilterPrivateModel","CreateFlpTask","UpdateFlpTask","DeleteFlpTask","SyncFlpTask","FolderLevelPermissionsFeature","CreateFolderFeature","UpdateFolderFeature","DeleteFolderFeature","GetFolderFeature","ListFoldersFeature","ListFolderLevelPermissionsTargetsFeature","GetFolderHierarchyFeature","GetAncestorsFeature","EnsureFolderIsEmptyFeature","CreateFlpFeature","UpdateFlpFeature","DeleteFlpFeature","ListFlpsFeature","GetFlpFeature","CreateFlpOnFolderCreatedFeature","UpdateFlpOnFolderUpdatedFeature","DeleteFlpOnFolderDeletedFeature","EnsureFolderIsEmptyOnDeleteFeature","EnsureHcmsFolderIsEmptyOnDeleteFeature","getTenant","TenantContext","storageOperations","getStorageOperations","cms","HeadlessCms","identityContext","IdentityContext","createFilterOperations","FlpStorageOperations","flpCrudMethods","getFlpCrudMethods","createFlpCrudMethods","AcoFlpCrud","FilterStorageOperations","filterCrudMethods","AcoFilterCrud","createFilterCrudMethods","FolderLevelPermissions","AcoInitializer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAMA;IACF,MAAM,QAAQC,OAA8B,EAAkC;QAG1EC,iBAAiBD;QACjBE,gBAAgBF;QAChB,OAAOA;IACX;AACJ;AAEA,MAAMG,mBAAmBC,qBAAqB,oBAAoB,CAAC;IAC/D,gBAAgBL;IAChB,cAAc,EAAE;AACpB;AAEO,MAAMM,aAAaC,cAAc;IACpC,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QAGnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QAInBC,8BAA8B,QAAQ,CAACP;QACvCQ,oBAAoB,QAAQ,CAACR;QAC7BS,oBAAoB,QAAQ,CAACT;QAC7BU,oBAAoB,QAAQ,CAACV;QAC7BW,iBAAiB,QAAQ,CAACX;QAC1BY,mBAAmB,QAAQ,CAACZ;QAC5Ba,yCAAyC,QAAQ,CAACb;QAClDc,0BAA0B,QAAQ,CAACd;QACnCe,oBAAoB,QAAQ,CAACf;QAC7BgB,2BAA2B,QAAQ,CAAChB;QACpCiB,iBAAiB,QAAQ,CAACjB;QAC1BkB,iBAAiB,QAAQ,CAAClB;QAC1BmB,iBAAiB,QAAQ,CAACnB;QAC1BoB,gBAAgB,QAAQ,CAACpB;QACzBqB,cAAc,QAAQ,CAACrB;QACvBsB,gCAAgC,QAAQ,CAACtB;QACzCuB,gCAAgC,QAAQ,CAACvB;QACzCwB,gCAAgC,QAAQ,CAACxB;QACzCyB,mCAAmC,QAAQ,CAACzB;QAC5C0B,uCAAuC,QAAQ,CAAC1B;QAMhD,MAAM2B,YAAY,IAAc3B,UAAU,OAAO,CAAC4B,eAAe,SAAS;QAE1E,IAAIC;QACJ,MAAMC,uBAAuB;YACzB,IAAI,CAACD,mBAAmB;gBACpB,MAAME,MAAM/B,UAAU,OAAO,CAACgC;gBAC9B,MAAMC,kBAAkBjC,UAAU,OAAO,CAACkC;gBAC1CL,oBAAoB;oBAChB,QAAQM,uBAAuB;wBAAEJ;wBAAKE;wBAAiBjC;oBAAU;oBACjE,KAAKA,UAAU,OAAO,CAACoC;gBAC3B;YACJ;YACA,OAAOP;QACX;QAEA,IAAIQ;QACJ,MAAMC,oBAAoB;YACtB,IAAI,CAACD,gBACDA,iBAAiBE,qBAAqB;gBAClCZ;gBACA,mBAAmBG;YACvB;YAEJ,OAAOO;QACX;QACArC,UAAU,eAAe,CAACwC,YAAY,IAAMF;QAC5CtC,UAAU,eAAe,CAACyC,yBAAyB,IAAMX,uBAAuB,MAAM;QAEtF,IAAIY;QACJ1C,UAAU,eAAe,CAAC2C,eAAe;YACrC,IAAI,CAACD,mBACDA,oBAAoBE,wBAAwB;gBACxC5C;gBACA2B;gBACA,mBAAmBG;gBACnB,wBAAwB9B,UAAU,OAAO,CAAC6C;YAC9C;YAEJ,OAAOH;QACX;QAEA1C,UAAU,QAAQ,CAAC8C;QACnB9C,UAAU,QAAQ,CAACJ;IACvB;AACJ"}
+{"version":3,"file":"AcoFeature.js","sources":["../src/AcoFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GraphQLSchemaFactory } from \"@webiny/api-graphql/graphql/abstractions.js\";\nimport type { IGraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\nimport type { Container } from \"@webiny/di\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { HeadlessCms } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport { addAcoBaseSchema } from \"./createAcoGraphQL.js\";\nimport { addFilterSchema } from \"~/filter/filter.gql.js\";\nimport { AcoFolderSchemaFactory } from \"./AcoFolderSchemaFactory.js\";\nimport { FolderModelProvider } from \"~/features/folder/FolderModelProvider.js\";\nimport { CmsFlpFeature } from \"~/features/cms/index.js\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { CreateFlpTask } from \"~/flp/tasks/createFlp.task.js\";\nimport { UpdateFlpTask } from \"~/flp/tasks/updateFlp.task.js\";\nimport { DeleteFlpTask } from \"~/flp/tasks/deleteFlp.task.js\";\nimport { SyncFlpTask } from \"~/flp/tasks/syncFlp.task.js\";\nimport type { AcoStorageOperations } from \"~/types.js\";\nimport type { Tenant } from \"@webiny/api-core/types/tenancy.js\";\nimport { FolderModel } from \"~/domain/folder/folder.model.js\";\nimport { FilterPrivateModel } from \"~/filter/filter.model.js\";\n// Facade wiring (moved here from createAcoContext so the ACO facade can be a lazy DI factory).\nimport { createFilterOperations } from \"~/filter/filter.so.js\";\nimport { createFilterCrudMethods } from \"~/filter/filter.crud.js\";\nimport { createFlpCrudMethods } from \"~/flp/index.js\";\nimport {\n    FolderLevelPermissions,\n    FolderLevelPermissionsFeature\n} from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { UpdateFolderFeature } from \"~/features/folder/UpdateFolder/index.js\";\nimport { DeleteFolderFeature } from \"~/features/folder/DeleteFolder/index.js\";\nimport { CreateFolderFeature } from \"~/features/folder/CreateFolder/index.js\";\nimport { GetFolderFeature } from \"~/features/folder/GetFolder/index.js\";\nimport { ListFoldersFeature } from \"~/features/folder/ListFolders/index.js\";\nimport { GetFolderHierarchyFeature } from \"~/features/folder/GetFolderHierarchy/index.js\";\nimport { GetAncestorsFeature } from \"~/features/folder/GetAncestors/index.js\";\nimport { UpdateFlpOnFolderUpdatedFeature } from \"~/features/flp/UpdateFlpOnFolderUpdated/index.js\";\nimport { DeleteFlpOnFolderDeletedFeature } from \"~/features/flp/DeleteFlpOnFolderDeleted/index.js\";\nimport { EnsureHcmsFolderIsEmptyOnDeleteFeature } from \"~/features/folder/EnsureHcmsFolderIsEmptyOnDelete/index.js\";\nimport { CreateFlpFeature } from \"~/features/flp/CreateFlp/index.js\";\nimport { DeleteFlpFeature } from \"~/features/flp/DeleteFlp/index.js\";\nimport { UpdateFlpFeature } from \"~/features/flp/UpdateFlp/index.js\";\nimport { EnsureFolderIsEmptyOnDeleteFeature } from \"~/features/folder/EnsureFolderIsEmptyOnDelete/index.js\";\nimport {\n    AcoFilterCrud,\n    AcoFlpCrud,\n    FilterStorageOperations,\n    FlpStorageOperations\n} from \"~/features/folder/shared/abstractions.js\";\nimport { ListFlpsFeature } from \"~/features/flp/ListFlps/feature.js\";\nimport { GetFlpFeature } from \"~/features/flp/GetFlp/feature.js\";\nimport { ListFolderLevelPermissionsTargetsFeature } from \"~/features/folder/ListFolderLevelPermissionsTargets/feature.js\";\nimport { CreateFlpOnFolderCreatedFeature } from \"~/features/flp/CreateFlpOnFolderCreated/index.js\";\nimport { EnsureFolderIsEmptyFeature } from \"~/features/folder/EnsureFolderIsEmpty/feature.js\";\nimport { AcoAiToolsFeature } from \"~/features/ai/index.js\";\n\nclass AcoSchemaFactoryImpl implements GraphQLSchemaFactory.Interface {\n    async execute(builder: IGraphQLSchemaBuilder): Promise<IGraphQLSchemaBuilder> {\n        // Static ACO base + filter schema (DI-native contributors declaring their deps). The\n        // dynamic, per-tenant folder schema is built by AcoFolderSchemaFactory.\n        addAcoBaseSchema(builder);\n        addFilterSchema(builder);\n        return builder;\n    }\n}\n\nconst AcoSchemaFactory = GraphQLSchemaFactory.createImplementation({\n    implementation: AcoSchemaFactoryImpl,\n    dependencies: []\n});\n\nexport const AcoFeature = createFeature({\n    name: \"Aco\",\n    register(container: Container) {\n        container.register(FolderModel);\n        AcoAiToolsFeature.register(container);\n        container.register(FilterPrivateModel);\n\n        // Background task definitions — pure wiring, no tenant/identity needed.\n        container.register(CreateFlpTask);\n        container.register(UpdateFlpTask);\n        container.register(DeleteFlpTask);\n        container.register(SyncFlpTask);\n\n        // Folder + FLP use-case features — pure DI wiring (all lazy). Moved out of the per-request\n        // initializer so they're registered for every event, not only GraphQL requests.\n        FolderLevelPermissionsFeature.register(container);\n        CreateFolderFeature.register(container);\n        UpdateFolderFeature.register(container);\n        DeleteFolderFeature.register(container);\n        GetFolderFeature.register(container);\n        ListFoldersFeature.register(container);\n        ListFolderLevelPermissionsTargetsFeature.register(container);\n        GetFolderHierarchyFeature.register(container);\n        GetAncestorsFeature.register(container);\n        EnsureFolderIsEmptyFeature.register(container);\n        CreateFlpFeature.register(container);\n        UpdateFlpFeature.register(container);\n        DeleteFlpFeature.register(container);\n        ListFlpsFeature.register(container);\n        GetFlpFeature.register(container);\n        CreateFlpOnFolderCreatedFeature.register(container);\n        UpdateFlpOnFolderUpdatedFeature.register(container);\n        DeleteFlpOnFolderDeletedFeature.register(container);\n        EnsureFolderIsEmptyOnDeleteFeature.register(container);\n        EnsureHcmsFolderIsEmptyOnDeleteFeature.register(container);\n\n        // ===== Lazy ACO facade =====\n        // Built on first resolve (post-auth) so the HeadlessCms facade (also lazy) is resolved on\n        // demand. Memoised per request container. Consumers resolve AcoFlpCrud / AcoFilterCrud /\n        // FilterStorageOperations via DI.\n        const getTenant = (): Tenant => container.resolve(TenantContext).getTenant();\n\n        let storageOperations: AcoStorageOperations | undefined;\n        const getStorageOperations = (): AcoStorageOperations => {\n            if (!storageOperations) {\n                const cms = container.resolve(HeadlessCms);\n                const identityContext = container.resolve(IdentityContext);\n                storageOperations = {\n                    filter: createFilterOperations({ cms, identityContext, container }),\n                    flp: container.resolve(FlpStorageOperations)\n                };\n            }\n            return storageOperations;\n        };\n\n        let flpCrudMethods: ReturnType<typeof createFlpCrudMethods> | undefined;\n        const getFlpCrudMethods = () => {\n            if (!flpCrudMethods) {\n                flpCrudMethods = createFlpCrudMethods({\n                    getTenant,\n                    storageOperations: getStorageOperations()\n                });\n            }\n            return flpCrudMethods;\n        };\n        container.registerFactory(AcoFlpCrud, () => getFlpCrudMethods());\n        container.registerFactory(FilterStorageOperations, () => getStorageOperations().filter);\n\n        let filterCrudMethods: ReturnType<typeof createFilterCrudMethods> | undefined;\n        container.registerFactory(AcoFilterCrud, () => {\n            if (!filterCrudMethods) {\n                filterCrudMethods = createFilterCrudMethods({\n                    container,\n                    getTenant,\n                    storageOperations: getStorageOperations(),\n                    folderLevelPermissions: container.resolve(FolderLevelPermissions)\n                });\n            }\n            return filterCrudMethods;\n        });\n\n        // The per-tenant folder model is resolved on demand — see FolderModelProvider.\n        container.register(FolderModelProvider);\n\n        // CMS-entry folder-level-permission decorators, feature-flag gated. These must be\n        // registered before any CMS-entry abstraction they wrap is first resolved, which is why\n        // they used to sit in a pre-resolver initializer. Register time is strictly earlier and the\n        // gate is valid here: the WCP license is refreshed before any feature registers (see\n        // registerApiRequestStack).\n        if (\n            container\n                .resolve(FeatureFlags)\n                .get()\n                .isEnabled(\"advancedAccessControlLayer.folderLevelPermissions\")\n        ) {\n            CmsFlpFeature.register(container);\n        }\n\n        container.register(AcoSchemaFactory);\n        container.register(AcoFolderSchemaFactory);\n    }\n});\n"],"names":["AcoSchemaFactoryImpl","builder","addAcoBaseSchema","addFilterSchema","AcoSchemaFactory","GraphQLSchemaFactory","AcoFeature","createFeature","container","FolderModel","AcoAiToolsFeature","FilterPrivateModel","CreateFlpTask","UpdateFlpTask","DeleteFlpTask","SyncFlpTask","FolderLevelPermissionsFeature","CreateFolderFeature","UpdateFolderFeature","DeleteFolderFeature","GetFolderFeature","ListFoldersFeature","ListFolderLevelPermissionsTargetsFeature","GetFolderHierarchyFeature","GetAncestorsFeature","EnsureFolderIsEmptyFeature","CreateFlpFeature","UpdateFlpFeature","DeleteFlpFeature","ListFlpsFeature","GetFlpFeature","CreateFlpOnFolderCreatedFeature","UpdateFlpOnFolderUpdatedFeature","DeleteFlpOnFolderDeletedFeature","EnsureFolderIsEmptyOnDeleteFeature","EnsureHcmsFolderIsEmptyOnDeleteFeature","getTenant","TenantContext","storageOperations","getStorageOperations","cms","HeadlessCms","identityContext","IdentityContext","createFilterOperations","FlpStorageOperations","flpCrudMethods","getFlpCrudMethods","createFlpCrudMethods","AcoFlpCrud","FilterStorageOperations","filterCrudMethods","AcoFilterCrud","createFilterCrudMethods","FolderLevelPermissions","FolderModelProvider","FeatureFlags","CmsFlpFeature","AcoFolderSchemaFactory"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAMA;IACF,MAAM,QAAQC,OAA8B,EAAkC;QAG1EC,iBAAiBD;QACjBE,gBAAgBF;QAChB,OAAOA;IACX;AACJ;AAEA,MAAMG,mBAAmBC,qBAAqB,oBAAoB,CAAC;IAC/D,gBAAgBL;IAChB,cAAc,EAAE;AACpB;AAEO,MAAMM,aAAaC,cAAc;IACpC,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;QACnBC,kBAAkB,QAAQ,CAACF;QAC3BA,UAAU,QAAQ,CAACG;QAGnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QAInBC,8BAA8B,QAAQ,CAACR;QACvCS,oBAAoB,QAAQ,CAACT;QAC7BU,oBAAoB,QAAQ,CAACV;QAC7BW,oBAAoB,QAAQ,CAACX;QAC7BY,iBAAiB,QAAQ,CAACZ;QAC1Ba,mBAAmB,QAAQ,CAACb;QAC5Bc,yCAAyC,QAAQ,CAACd;QAClDe,0BAA0B,QAAQ,CAACf;QACnCgB,oBAAoB,QAAQ,CAAChB;QAC7BiB,2BAA2B,QAAQ,CAACjB;QACpCkB,iBAAiB,QAAQ,CAAClB;QAC1BmB,iBAAiB,QAAQ,CAACnB;QAC1BoB,iBAAiB,QAAQ,CAACpB;QAC1BqB,gBAAgB,QAAQ,CAACrB;QACzBsB,cAAc,QAAQ,CAACtB;QACvBuB,gCAAgC,QAAQ,CAACvB;QACzCwB,gCAAgC,QAAQ,CAACxB;QACzCyB,gCAAgC,QAAQ,CAACzB;QACzC0B,mCAAmC,QAAQ,CAAC1B;QAC5C2B,uCAAuC,QAAQ,CAAC3B;QAMhD,MAAM4B,YAAY,IAAc5B,UAAU,OAAO,CAAC6B,eAAe,SAAS;QAE1E,IAAIC;QACJ,MAAMC,uBAAuB;YACzB,IAAI,CAACD,mBAAmB;gBACpB,MAAME,MAAMhC,UAAU,OAAO,CAACiC;gBAC9B,MAAMC,kBAAkBlC,UAAU,OAAO,CAACmC;gBAC1CL,oBAAoB;oBAChB,QAAQM,uBAAuB;wBAAEJ;wBAAKE;wBAAiBlC;oBAAU;oBACjE,KAAKA,UAAU,OAAO,CAACqC;gBAC3B;YACJ;YACA,OAAOP;QACX;QAEA,IAAIQ;QACJ,MAAMC,oBAAoB;YACtB,IAAI,CAACD,gBACDA,iBAAiBE,qBAAqB;gBAClCZ;gBACA,mBAAmBG;YACvB;YAEJ,OAAOO;QACX;QACAtC,UAAU,eAAe,CAACyC,YAAY,IAAMF;QAC5CvC,UAAU,eAAe,CAAC0C,yBAAyB,IAAMX,uBAAuB,MAAM;QAEtF,IAAIY;QACJ3C,UAAU,eAAe,CAAC4C,eAAe;YACrC,IAAI,CAACD,mBACDA,oBAAoBE,wBAAwB;gBACxC7C;gBACA4B;gBACA,mBAAmBG;gBACnB,wBAAwB/B,UAAU,OAAO,CAAC8C;YAC9C;YAEJ,OAAOH;QACX;QAGA3C,UAAU,QAAQ,CAAC+C;QAOnB,IACI/C,UACK,OAAO,CAACgD,cACR,GAAG,GACH,SAAS,CAAC,sDAEfC,cAAc,QAAQ,CAACjD;QAG3BA,UAAU,QAAQ,CAACJ;QACnBI,UAAU,QAAQ,CAACkD;IACvB;AACJ"}

package/AcoFolderSchemaFactory.d.ts

@@ -0,0 +1,30 @@
+import { CoreGraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import type { IGraphQLSchemaBuilder } from "@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { FolderModelProvider } from "./domain/folder/abstractions.js";
+/**
+ * Builds the dynamic folder GraphQL schema — the `Folder` type's fields are rendered from the
+ * tenant's folder model, so the shape differs per tenant.
+ *
+ * Previously done by `AcoInitializer`, which had to run as a per-request hook before any resolver:
+ * it fetched the model, then registered one `CoreGraphQLSchemaFactory` per generated plugin. That
+ * indirection is unnecessary — `CoreGraphQLSchemaFactory.execute()` is already awaited by
+ * `GraphQLSchemaComposer`, so this factory can be registered once at compose time and do its async
+ * work inside `execute()`, at the moment the schema is actually built.
+ */
+declare class AcoFolderSchemaFactoryImpl implements CoreGraphQLSchemaFactory.Interface {
+    private folderModelProvider;
+    private listModels;
+    private fieldRegistry;
+    private identityContext;
+    private tenantContext;
+    constructor(folderModelProvider: FolderModelProvider.Interface, listModels: ListModelsUseCase.Interface, fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface, identityContext: IdentityContext.Interface, tenantContext: TenantContext.Interface);
+    execute(builder: IGraphQLSchemaBuilder): Promise<IGraphQLSchemaBuilder>;
+}
+export declare const AcoFolderSchemaFactory: typeof AcoFolderSchemaFactoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-graphql/graphql/abstractions.core").ICoreGraphQLSchemaFactory>;
+};
+export {};

package/AcoFolderSchemaFactory.js

@@ -0,0 +1,64 @@
+import { GraphQLSchemaPlugin } from "@webiny/api-graphql";
+import { CoreGraphQLSchemaFactory } from "@webiny/api-graphql/graphql/abstractions.js";
+import { TenantContext } from "@webiny/api-core/features/tenancy/TenantContext/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/features/contentModel/ListModels/index.js";
+import { CmsModelFieldToGraphQLRegistry } from "@webiny/api-headless-cms/exports/api/cms/graphql.js";
+import { createGraphQLSchemaPluginFromFieldPlugins } from "@webiny/api-headless-cms/utils/getSchemaFromFieldPlugins.js";
+import { FolderModelProvider } from "./domain/folder/abstractions.js";
+import { createFoldersSchema } from "./folder/folder.gql.js";
+class AcoFolderSchemaFactoryImpl {
+    constructor(folderModelProvider, listModels, fieldRegistry, identityContext, tenantContext){
+        this.folderModelProvider = folderModelProvider;
+        this.listModels = listModels;
+        this.fieldRegistry = fieldRegistry;
+        this.identityContext = identityContext;
+        this.tenantContext = tenantContext;
+    }
+    async execute(builder) {
+        if (!this.tenantContext.getTenant()) return builder;
+        const model = await this.folderModelProvider.get();
+        const models = await this.identityContext.withoutAuthorization(async ()=>{
+            const result = await this.listModels.execute();
+            if (result.isFail()) throw result.error;
+            return result.value;
+        });
+        const fieldPlugins = createGraphQLSchemaPluginFromFieldPlugins({
+            models,
+            type: "manage",
+            fieldRegistry: this.fieldRegistry,
+            createPlugin: ({ schema, type, fieldType })=>{
+                const plugin = new GraphQLSchemaPlugin(schema);
+                plugin.name = `aco.graphql.folder.schema.${type}.field.${fieldType}`;
+                return plugin;
+            }
+        });
+        const folderPlugin = createFoldersSchema({
+            model,
+            models,
+            fieldRegistry: this.fieldRegistry
+        });
+        for (const plugin of [
+            ...fieldPlugins,
+            folderPlugin
+        ]){
+            if (plugin.schema.typeDefs) builder.addTypeDefs(plugin.schema.typeDefs);
+            if (plugin.schema.resolvers) builder.addLegacyResolvers(plugin.schema.resolvers);
+            if (plugin.schema.resolverDecorators) for (const [path, decorators] of Object.entries(plugin.schema.resolverDecorators))for (const decorator of decorators)builder.addResolverDecorator(path, decorator);
+        }
+        return builder;
+    }
+}
+const AcoFolderSchemaFactory = CoreGraphQLSchemaFactory.createImplementation({
+    implementation: AcoFolderSchemaFactoryImpl,
+    dependencies: [
+        FolderModelProvider,
+        ListModelsUseCase,
+        CmsModelFieldToGraphQLRegistry,
+        IdentityContext,
+        TenantContext
+    ]
+});
+export { AcoFolderSchemaFactory };
+
+//# sourceMappingURL=AcoFolderSchemaFactory.js.map

package/AcoFolderSchemaFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcoFolderSchemaFactory.js","sources":["../src/AcoFolderSchemaFactory.ts"],"sourcesContent":["import { GraphQLSchemaPlugin } from \"@webiny/api-graphql\";\nimport { CoreGraphQLSchemaFactory } from \"@webiny/api-graphql/graphql/abstractions.js\";\nimport type { IGraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\nimport type { IGraphQLSchemaPlugin } from \"@webiny/api-graphql/plugins/GraphQLSchemaPlugin.js\";\nimport { TenantContext } from \"@webiny/api-core/features/tenancy/TenantContext/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport { ListModelsUseCase } from \"@webiny/api-headless-cms/features/contentModel/ListModels/index.js\";\nimport { CmsModelFieldToGraphQLRegistry } from \"@webiny/api-headless-cms/exports/api/cms/graphql.js\";\nimport { createGraphQLSchemaPluginFromFieldPlugins } from \"@webiny/api-headless-cms/utils/getSchemaFromFieldPlugins.js\";\nimport { FolderModelProvider } from \"~/domain/folder/abstractions.js\";\nimport { createFoldersSchema } from \"~/folder/folder.gql.js\";\n\n/**\n * Builds the dynamic folder GraphQL schema — the `Folder` type's fields are rendered from the\n * tenant's folder model, so the shape differs per tenant.\n *\n * Previously done by `AcoInitializer`, which had to run as a per-request hook before any resolver:\n * it fetched the model, then registered one `CoreGraphQLSchemaFactory` per generated plugin. That\n * indirection is unnecessary — `CoreGraphQLSchemaFactory.execute()` is already awaited by\n * `GraphQLSchemaComposer`, so this factory can be registered once at compose time and do its async\n * work inside `execute()`, at the moment the schema is actually built.\n */\nclass AcoFolderSchemaFactoryImpl implements CoreGraphQLSchemaFactory.Interface {\n    constructor(\n        private folderModelProvider: FolderModelProvider.Interface,\n        private listModels: ListModelsUseCase.Interface,\n        private fieldRegistry: CmsModelFieldToGraphQLRegistry.Interface,\n        private identityContext: IdentityContext.Interface,\n        private tenantContext: TenantContext.Interface\n    ) {}\n\n    async execute(builder: IGraphQLSchemaBuilder): Promise<IGraphQLSchemaBuilder> {\n        // On a fresh project there is no tenant until installation completes, and there is no model\n        // to render a schema from. (This is what `isHeadlessCmsReady` checked in the initializer.)\n        if (!this.tenantContext.getTenant()) {\n            return builder;\n        }\n\n        const model = await this.folderModelProvider.get();\n\n        // The model list feeds `ref` field rendering, so it must be the COMPLETE set — access\n        // control filters models by permission, which would otherwise make the generated schema\n        // vary by identity. Hence the unauthorized read, exactly as the initializer did.\n        const models = await this.identityContext.withoutAuthorization(async () => {\n            const result = await this.listModels.execute();\n            if (result.isFail()) {\n                throw result.error;\n            }\n            return result.value;\n        });\n\n        const fieldPlugins = createGraphQLSchemaPluginFromFieldPlugins({\n            models,\n            type: \"manage\",\n            fieldRegistry: this.fieldRegistry,\n            createPlugin: ({ schema, type, fieldType }) => {\n                const plugin = new GraphQLSchemaPlugin(schema);\n                plugin.name = `aco.graphql.folder.schema.${type}.field.${fieldType}`;\n                return plugin;\n            }\n        });\n\n        const folderPlugin = createFoldersSchema({\n            model,\n            models,\n            fieldRegistry: this.fieldRegistry\n        });\n\n        for (const plugin of [...fieldPlugins, folderPlugin] as IGraphQLSchemaPlugin[]) {\n            if (plugin.schema.typeDefs) {\n                builder.addTypeDefs(plugin.schema.typeDefs);\n            }\n            if (plugin.schema.resolvers) {\n                builder.addLegacyResolvers(plugin.schema.resolvers as Record<string, any>);\n            }\n            if (plugin.schema.resolverDecorators) {\n                for (const [path, decorators] of Object.entries(plugin.schema.resolverDecorators)) {\n                    for (const decorator of decorators as any[]) {\n                        builder.addResolverDecorator(path, decorator);\n                    }\n                }\n            }\n        }\n\n        return builder;\n    }\n}\n\nexport const AcoFolderSchemaFactory = CoreGraphQLSchemaFactory.createImplementation({\n    implementation: AcoFolderSchemaFactoryImpl,\n    dependencies: [\n        FolderModelProvider,\n        ListModelsUseCase,\n        CmsModelFieldToGraphQLRegistry,\n        IdentityContext,\n        TenantContext\n    ]\n});\n"],"names":["AcoFolderSchemaFactoryImpl","folderModelProvider","listModels","fieldRegistry","identityContext","tenantContext","builder","model","models","result","fieldPlugins","createGraphQLSchemaPluginFromFieldPlugins","schema","type","fieldType","plugin","GraphQLSchemaPlugin","folderPlugin","createFoldersSchema","path","decorators","Object","decorator","AcoFolderSchemaFactory","CoreGraphQLSchemaFactory","FolderModelProvider","ListModelsUseCase","CmsModelFieldToGraphQLRegistry","IdentityContext","TenantContext"],"mappings":";;;;;;;;;AAsBA,MAAMA;IACF,YACYC,mBAAkD,EAClDC,UAAuC,EACvCC,aAAuD,EACvDC,eAA0C,EAC1CC,aAAsC,CAChD;aALUJ,mBAAmB,GAAnBA;aACAC,UAAU,GAAVA;aACAC,aAAa,GAAbA;aACAC,eAAe,GAAfA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,OAA8B,EAAkC;QAG1E,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,SAAS,IAC7B,OAAOA;QAGX,MAAMC,QAAQ,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG;QAKhD,MAAMC,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC;YAC3D,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO;YAC5C,IAAIA,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;YAEtB,OAAOA,OAAO,KAAK;QACvB;QAEA,MAAMC,eAAeC,0CAA0C;YAC3DH;YACA,MAAM;YACN,eAAe,IAAI,CAAC,aAAa;YACjC,cAAc,CAAC,EAAEI,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAE;gBACtC,MAAMC,SAAS,IAAIC,oBAAoBJ;gBACvCG,OAAO,IAAI,GAAG,CAAC,0BAA0B,EAAEF,KAAK,OAAO,EAAEC,WAAW;gBACpE,OAAOC;YACX;QACJ;QAEA,MAAME,eAAeC,oBAAoB;YACrCX;YACAC;YACA,eAAe,IAAI,CAAC,aAAa;QACrC;QAEA,KAAK,MAAMO,UAAU;eAAIL;YAAcO;SAAa,CAA4B;YAC5E,IAAIF,OAAO,MAAM,CAAC,QAAQ,EACtBT,QAAQ,WAAW,CAACS,OAAO,MAAM,CAAC,QAAQ;YAE9C,IAAIA,OAAO,MAAM,CAAC,SAAS,EACvBT,QAAQ,kBAAkB,CAACS,OAAO,MAAM,CAAC,SAAS;YAEtD,IAAIA,OAAO,MAAM,CAAC,kBAAkB,EAChC,KAAK,MAAM,CAACI,MAAMC,WAAW,IAAIC,OAAO,OAAO,CAACN,OAAO,MAAM,CAAC,kBAAkB,EAC5E,KAAK,MAAMO,aAAaF,WACpBd,QAAQ,oBAAoB,CAACa,MAAMG;QAInD;QAEA,OAAOhB;IACX;AACJ;AAEO,MAAMiB,yBAAyBC,yBAAyB,oBAAoB,CAAC;IAChF,gBAAgBxB;IAChB,cAAc;QACVyB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/createAcoGraphQL.d.ts

@@ -1,7 +1,8 @@
 import type { IGraphQLSchemaBuilder } from "@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js";
 /**
  * The static ACO base schema (root Query.aco / Mutation.aco wrappers + shared types). The dynamic
- * folder schema (field plugins + folders schema) is built per-request by AcoInitializer, which needs
- * the resolved per-tenant folder model. The filter schema is contributed by addFilterSchema.
+ * folder schema (field plugins + folders schema) is built by AcoFolderSchemaFactory, which awaits
+ * the per-tenant folder model when the schema is built. The filter schema comes from
+ * addFilterSchema.
  */
 export declare const addAcoBaseSchema: (builder: IGraphQLSchemaBuilder) => void;

package/createAcoGraphQL.js.map

@@ -1 +1 @@
-{"version":3,"file":"createAcoGraphQL.js","sources":["../src/createAcoGraphQL.ts"],"sourcesContent":["import type { IGraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\n\nconst BASE_TYPE_DEFS = /* GraphQL */ `\n    type AcoQuery {\n        _empty: String\n    }\n\n    type AcoMutation {\n        _empty: String\n    }\n\n    type AcoMeta {\n        hasMoreItems: Boolean\n        totalCount: Int\n        cursor: String\n    }\n\n    type AcoUser {\n        id: ID\n        displayName: String\n        type: String\n    }\n\n    type AcoError {\n        code: String\n        message: String\n        data: JSON\n        stack: String\n    }\n\n    type AcoBooleanResponse {\n        data: Boolean\n        error: AcoError\n    }\n\n    enum AcoSortDirection {\n        ASC\n        DESC\n    }\n\n    input AcoSort {\n        id: AcoSortDirection\n        createdOn: AcoSortDirection\n        modifiedOn: AcoSortDirection\n        savedOn: AcoSortDirection\n        title: AcoSortDirection\n    }\n\n    extend type Query {\n        aco: AcoQuery\n    }\n\n    extend type Mutation {\n        aco: AcoMutation\n    }\n`;\n\n/**\n * The static ACO base schema (root Query.aco / Mutation.aco wrappers + shared types). The dynamic\n * folder schema (field plugins + folders schema) is built per-request by AcoInitializer, which needs\n * the resolved per-tenant folder model. The filter schema is contributed by addFilterSchema.\n */\nexport const addAcoBaseSchema = (builder: IGraphQLSchemaBuilder): void => {\n    builder.addTypeDefs(BASE_TYPE_DEFS);\n    builder.addResolver({ path: \"Query.aco\", dependencies: [], resolver: () => () => ({}) });\n    builder.addResolver({ path: \"Mutation.aco\", dependencies: [], resolver: () => () => ({}) });\n};\n"],"names":["BASE_TYPE_DEFS","addAcoBaseSchema","builder"],"mappings":"AAEA,MAAMA,iBAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDtC,CAAC;AAOM,MAAMC,mBAAmB,CAACC;IAC7BA,QAAQ,WAAW,CAACF;IACpBE,QAAQ,WAAW,CAAC;QAAE,MAAM;QAAa,cAAc,EAAE;QAAE,UAAU,IAAM,IAAO,EAAC;IAAG;IACtFA,QAAQ,WAAW,CAAC;QAAE,MAAM;QAAgB,cAAc,EAAE;QAAE,UAAU,IAAM,IAAO,EAAC;IAAG;AAC7F"}
+{"version":3,"file":"createAcoGraphQL.js","sources":["../src/createAcoGraphQL.ts"],"sourcesContent":["import type { IGraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\n\nconst BASE_TYPE_DEFS = /* GraphQL */ `\n    type AcoQuery {\n        _empty: String\n    }\n\n    type AcoMutation {\n        _empty: String\n    }\n\n    type AcoMeta {\n        hasMoreItems: Boolean\n        totalCount: Int\n        cursor: String\n    }\n\n    type AcoUser {\n        id: ID\n        displayName: String\n        type: String\n    }\n\n    type AcoError {\n        code: String\n        message: String\n        data: JSON\n        stack: String\n    }\n\n    type AcoBooleanResponse {\n        data: Boolean\n        error: AcoError\n    }\n\n    enum AcoSortDirection {\n        ASC\n        DESC\n    }\n\n    input AcoSort {\n        id: AcoSortDirection\n        createdOn: AcoSortDirection\n        modifiedOn: AcoSortDirection\n        savedOn: AcoSortDirection\n        title: AcoSortDirection\n    }\n\n    extend type Query {\n        aco: AcoQuery\n    }\n\n    extend type Mutation {\n        aco: AcoMutation\n    }\n`;\n\n/**\n * The static ACO base schema (root Query.aco / Mutation.aco wrappers + shared types). The dynamic\n * folder schema (field plugins + folders schema) is built by AcoFolderSchemaFactory, which awaits\n * the per-tenant folder model when the schema is built. The filter schema comes from\n * addFilterSchema.\n */\nexport const addAcoBaseSchema = (builder: IGraphQLSchemaBuilder): void => {\n    builder.addTypeDefs(BASE_TYPE_DEFS);\n    builder.addResolver({ path: \"Query.aco\", dependencies: [], resolver: () => () => ({}) });\n    builder.addResolver({ path: \"Mutation.aco\", dependencies: [], resolver: () => () => ({}) });\n};\n"],"names":["BASE_TYPE_DEFS","addAcoBaseSchema","builder"],"mappings":"AAEA,MAAMA,iBAA+B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDtC,CAAC;AAQM,MAAMC,mBAAmB,CAACC;IAC7BA,QAAQ,WAAW,CAACF;IACpBE,QAAQ,WAAW,CAAC;QAAE,MAAM;QAAa,cAAc,EAAE;QAAE,UAAU,IAAM,IAAO,EAAC;IAAG;IACtFA,QAAQ,WAAW,CAAC;QAAE,MAAM;QAAgB,cAAc,EAAE;QAAE,UAAU,IAAM,IAAO,EAAC;IAAG;AAC7F"}

package/domain/folder/abstractions.d.ts

@@ -1,9 +1,16 @@
 import type { CmsModel } from "@webiny/api-headless-cms/types";
 /**
- * FolderModel abstraction - represents the ACO folder CMS model.
- * This will be registered via container.registerInstance in the composite feature.
+ * Provides the tenant's ACO folder CMS model.
+ *
+ * A provider rather than the model itself: fetching a model is asynchronous and tenant-dependent,
+ * while DI resolution is synchronous — so an already-resolved `CmsModel` could only be supplied by a
+ * per-request hook running before every consumer (what `AcoInitializer` used to do). Consumers
+ * `await get()` at the point of use.
  */
-export declare const FolderModel: import("@webiny/di").Abstraction<CmsModel>;
-export declare namespace FolderModel {
-    type Interface = CmsModel;
+export interface IFolderModelProvider {
+    get(): Promise<CmsModel>;
+}
+export declare const FolderModelProvider: import("@webiny/di").Abstraction<IFolderModelProvider>;
+export declare namespace FolderModelProvider {
+    type Interface = IFolderModelProvider;
 }

package/domain/folder/abstractions.js

@@ -1,5 +1,5 @@
 import { createAbstraction } from "@webiny/feature/api";
-const FolderModel = createAbstraction("FolderModel");
-export { FolderModel };
+const FolderModelProvider = createAbstraction("FolderModelProvider");
+export { FolderModelProvider };
 
 //# sourceMappingURL=abstractions.js.map

package/domain/folder/abstractions.js.map

@@ -1 +1 @@
-{"version":3,"file":"domain/folder/abstractions.js","sources":["../../../src/domain/folder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\n\n/**\n * FolderModel abstraction - represents the ACO folder CMS model.\n * This will be registered via container.registerInstance in the composite feature.\n */\nexport const FolderModel = createAbstraction<CmsModel>(\"FolderModel\");\n\nexport namespace FolderModel {\n    export type Interface = CmsModel;\n}\n"],"names":["FolderModel","createAbstraction"],"mappings":";AAOO,MAAMA,cAAcC,kBAA4B"}
+{"version":3,"file":"domain/folder/abstractions.js","sources":["../../../src/domain/folder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\n\n/**\n * Provides the tenant's ACO folder CMS model.\n *\n * A provider rather than the model itself: fetching a model is asynchronous and tenant-dependent,\n * while DI resolution is synchronous — so an already-resolved `CmsModel` could only be supplied by a\n * per-request hook running before every consumer (what `AcoInitializer` used to do). Consumers\n * `await get()` at the point of use.\n */\nexport interface IFolderModelProvider {\n    get(): Promise<CmsModel>;\n}\n\nexport const FolderModelProvider = createAbstraction<IFolderModelProvider>(\"FolderModelProvider\");\n\nexport namespace FolderModelProvider {\n    export type Interface = IFolderModelProvider;\n}\n"],"names":["FolderModelProvider","createAbstraction"],"mappings":";AAeO,MAAMA,sBAAsBC,kBAAwC"}

package/features/ai/CreateFolderTool.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import type { IAiSdkTool } from "@webiny/api-core/features/ai/index.js";
+import { CreateFolderUseCase } from "../../features/folder/CreateFolder/index.js";
+declare const inputSchema: z.ZodObject<{
+    title: z.ZodString;
+    slug: z.ZodString;
+    type: z.ZodString;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Input = z.infer<typeof inputSchema>;
+interface CreatedFolder {
+    id: string;
+    title: string;
+    slug: string;
+    path: string;
+    type: string;
+}
+/**
+ * Creates a folder.
+ *
+ * Additive and reversible, so it is not flagged destructive — but it still changes the project, so it
+ * is not read-only either and therefore needs the user to approve the exact arguments.
+ */
+declare class CreateFolderToolImpl implements IAiSdkTool<Input> {
+    private createFolder;
+    readonly name = "createFolder";
+    readonly title = "Create folder";
+    readonly description = "Creates a folder in the File Manager ('FmFile') or under a content model ('cms:<modelId>'). Call listFolders first to pick a parent, or omit parentId for the root. Requires user approval.";
+    readonly inputSchema: z.ZodObject<{
+        title: z.ZodString;
+        slug: z.ZodString;
+        type: z.ZodString;
+        parentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readOnlyHint: boolean;
+    };
+    constructor(createFolder: CreateFolderUseCase.Interface);
+    execute(input: Input): Promise<CreatedFolder>;
+}
+export declare const CreateFolderTool: typeof CreateFolderToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAiSdkTool<any>>;
+};
+export {};

package/features/ai/CreateFolderTool.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { AiSdkTool } from "@webiny/api-core/features/ai/index.js";
+import { CreateFolderUseCase } from "../folder/CreateFolder/index.js";
+const inputSchema = z.object({
+    title: z.string().describe("Human-readable folder name, e.g. 'Marketing'."),
+    slug: z.string().describe("URL-safe identifier, e.g. 'marketing'. Lowercase, hyphens instead of spaces."),
+    type: z.string().describe("Folder namespace: 'FmFile' for File Manager, or 'cms:<modelId>' for a content model's folders."),
+    parentId: z.string().optional().describe("Id of the parent folder. Omit to create at the root of that namespace.")
+});
+class CreateFolderToolImpl {
+    constructor(createFolder){
+        this.createFolder = createFolder;
+        this.name = "createFolder";
+        this.title = "Create folder";
+        this.description = "Creates a folder in the File Manager ('FmFile') or under a content model ('cms:<modelId>'). Call listFolders first to pick a parent, or omit parentId for the root. Requires user approval.";
+        this.inputSchema = inputSchema;
+        this.annotations = {
+            readOnlyHint: false
+        };
+    }
+    async execute(input) {
+        const params = {
+            title: input.title,
+            slug: input.slug,
+            type: input.type,
+            parentId: null
+        };
+        if (input.parentId) params.parentId = input.parentId;
+        const result = await this.createFolder.execute(params);
+        if (result.isFail()) throw new Error(`Could not create the folder: ${result.error.message}`);
+        const folder = result.value;
+        return {
+            id: folder.id,
+            title: folder.title,
+            slug: folder.slug,
+            path: folder.path,
+            type: folder.type
+        };
+    }
+}
+const CreateFolderTool = AiSdkTool.createImplementation({
+    implementation: CreateFolderToolImpl,
+    dependencies: [
+        CreateFolderUseCase
+    ]
+});
+export { CreateFolderTool };
+
+//# sourceMappingURL=CreateFolderTool.js.map

package/features/ai/CreateFolderTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/CreateFolderTool.js","sources":["../../../src/features/ai/CreateFolderTool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiSdkTool } from \"@webiny/api-core/features/ai/index.js\";\nimport type { IAiSdkTool } from \"@webiny/api-core/features/ai/index.js\";\nimport { CreateFolderUseCase } from \"~/features/folder/CreateFolder/index.js\";\n\nconst inputSchema = z.object({\n    title: z.string().describe(\"Human-readable folder name, e.g. 'Marketing'.\"),\n    slug: z\n        .string()\n        .describe(\"URL-safe identifier, e.g. 'marketing'. Lowercase, hyphens instead of spaces.\"),\n    type: z\n        .string()\n        .describe(\n            \"Folder namespace: 'FmFile' for File Manager, or 'cms:<modelId>' for a content model's folders.\"\n        ),\n    parentId: z\n        .string()\n        .optional()\n        .describe(\"Id of the parent folder. Omit to create at the root of that namespace.\")\n});\n\ntype Input = z.infer<typeof inputSchema>;\n\ninterface CreatedFolder {\n    id: string;\n    title: string;\n    slug: string;\n    path: string;\n    type: string;\n}\n\n/**\n * Creates a folder.\n *\n * Additive and reversible, so it is not flagged destructive — but it still changes the project, so it\n * is not read-only either and therefore needs the user to approve the exact arguments.\n */\nclass CreateFolderToolImpl implements IAiSdkTool<Input> {\n    readonly name = \"createFolder\";\n    readonly title = \"Create folder\";\n    readonly description =\n        \"Creates a folder in the File Manager ('FmFile') or under a content model ('cms:<modelId>'). Call listFolders first to pick a parent, or omit parentId for the root. Requires user approval.\";\n    readonly inputSchema = inputSchema;\n    readonly annotations = { readOnlyHint: false };\n\n    constructor(private createFolder: CreateFolderUseCase.Interface) {}\n\n    async execute(input: Input): Promise<CreatedFolder> {\n        const params: {\n            title: string;\n            slug: string;\n            type: string;\n            parentId: string | null;\n        } = {\n            title: input.title,\n            slug: input.slug,\n            type: input.type,\n            parentId: null\n        };\n\n        if (input.parentId) {\n            params.parentId = input.parentId;\n        }\n\n        const result = await this.createFolder.execute(params);\n\n        if (result.isFail()) {\n            throw new Error(`Could not create the folder: ${result.error.message}`);\n        }\n\n        const folder = result.value;\n\n        return {\n            id: folder.id,\n            title: folder.title,\n            slug: folder.slug,\n            path: folder.path,\n            type: folder.type\n        };\n    }\n}\n\nexport const CreateFolderTool = AiSdkTool.createImplementation({\n    implementation: CreateFolderToolImpl,\n    dependencies: [CreateFolderUseCase]\n});\n"],"names":["inputSchema","z","CreateFolderToolImpl","createFolder","input","params","result","Error","folder","CreateFolderTool","AiSdkTool","CreateFolderUseCase"],"mappings":";;;AAKA,MAAMA,cAAcC,EAAE,MAAM,CAAC;IACzB,OAAOA,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC3B,MAAMA,EAAAA,MACK,GACN,QAAQ,CAAC;IACd,MAAMA,EAAAA,MACK,GACN,QAAQ,CACL;IAER,UAAUA,EAAAA,MACC,GACN,QAAQ,GACR,QAAQ,CAAC;AAClB;AAkBA,MAAMC;IAQF,YAAoBC,YAA2C,CAAE;aAA7CA,YAAY,GAAZA;aAPX,IAAI,GAAG;aACP,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAGH;aACd,WAAW,GAAG;YAAE,cAAc;QAAM;IAEqB;IAElE,MAAM,QAAQI,KAAY,EAA0B;QAChD,MAAMC,SAKF;YACA,OAAOD,MAAM,KAAK;YAClB,MAAMA,MAAM,IAAI;YAChB,MAAMA,MAAM,IAAI;YAChB,UAAU;QACd;QAEA,IAAIA,MAAM,QAAQ,EACdC,OAAO,QAAQ,GAAGD,MAAM,QAAQ;QAGpC,MAAME,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAACD;QAE/C,IAAIC,OAAO,MAAM,IACb,MAAM,IAAIC,MAAM,CAAC,6BAA6B,EAAED,OAAO,KAAK,CAAC,OAAO,EAAE;QAG1E,MAAME,SAASF,OAAO,KAAK;QAE3B,OAAO;YACH,IAAIE,OAAO,EAAE;YACb,OAAOA,OAAO,KAAK;YACnB,MAAMA,OAAO,IAAI;YACjB,MAAMA,OAAO,IAAI;YACjB,MAAMA,OAAO,IAAI;QACrB;IACJ;AACJ;AAEO,MAAMC,mBAAmBC,UAAU,oBAAoB,CAAC;IAC3D,gBAAgBR;IAChB,cAAc;QAACS;KAAoB;AACvC"}

package/features/ai/CreateTeamTool.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import type { IAiSdkTool } from "@webiny/api-core/features/ai/index.js";
+import { CreateTeam } from "@webiny/api-core/features/security/teams/CreateTeam/index.js";
+declare const inputSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    roles: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type Input = z.infer<typeof inputSchema>;
+interface CreatedTeam {
+    id: string;
+    name: string;
+    slug: string;
+    roles: string[];
+}
+/**
+ * Creates a team.
+ *
+ * Not read-only, so it needs approval: a team is an access-control object, and the roles it carries
+ * decide what its members can do. The user should see which roles are being granted before it exists.
+ */
+declare class CreateTeamToolImpl implements IAiSdkTool<Input> {
+    private createTeam;
+    readonly name = "createTeam";
+    readonly title = "Create team";
+    readonly description = "Creates a team with a set of roles. Call listRoles first and pass what it returns; do not guess role identifiers. Requires user approval.";
+    readonly inputSchema: z.ZodObject<{
+        name: z.ZodString;
+        slug: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        roles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readOnlyHint: boolean;
+    };
+    constructor(createTeam: CreateTeam.Interface);
+    execute(input: Input): Promise<CreatedTeam>;
+}
+export declare const CreateTeamTool: typeof CreateTeamToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAiSdkTool<any>>;
+};
+export {};

package/features/ai/CreateTeamTool.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { AiSdkTool } from "@webiny/api-core/features/ai/index.js";
+import { CreateTeam } from "@webiny/api-core/features/security/teams/CreateTeam/index.js";
+import { descriptionOnCreate } from "@webiny/api-core/features/security/shared/index.js";
+const inputSchema = z.object({
+    name: z.string().describe("Human-readable team name, e.g. 'Marketing'."),
+    slug: z.string().describe("URL-safe identifier, e.g. 'marketing'. Lowercase, hyphens instead of spaces."),
+    description: z.string().max(500).optional().describe("What the team is for. Shown in the admin UI. Omit it if the user did not say."),
+    roles: z.array(z.string()).describe("Roles from listRoles. Prefer the `id`; a `slug` is accepted and resolved for you. Resolve them with listRoles first, since an unknown value is rejected rather than stored.")
+});
+class CreateTeamToolImpl {
+    constructor(createTeam){
+        this.createTeam = createTeam;
+        this.name = "createTeam";
+        this.title = "Create team";
+        this.description = "Creates a team with a set of roles. Call listRoles first and pass what it returns; do not guess role identifiers. Requires user approval.";
+        this.inputSchema = inputSchema;
+        this.annotations = {
+            readOnlyHint: false
+        };
+    }
+    async execute(input) {
+        const result = await this.createTeam.execute({
+            name: input.name,
+            slug: input.slug,
+            description: descriptionOnCreate(input.description),
+            roles: input.roles
+        });
+        if (result.isFail()) throw new Error(`Could not create the team: ${result.error.message}`);
+        const team = result.value;
+        return {
+            id: team.id,
+            name: team.name,
+            slug: team.slug,
+            roles: team.roles
+        };
+    }
+}
+const CreateTeamTool = AiSdkTool.createImplementation({
+    implementation: CreateTeamToolImpl,
+    dependencies: [
+        CreateTeam
+    ]
+});
+export { CreateTeamTool };
+
+//# sourceMappingURL=CreateTeamTool.js.map

package/features/ai/CreateTeamTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/ai/CreateTeamTool.js","sources":["../../../src/features/ai/CreateTeamTool.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiSdkTool } from \"@webiny/api-core/features/ai/index.js\";\nimport type { IAiSdkTool } from \"@webiny/api-core/features/ai/index.js\";\nimport { CreateTeam } from \"@webiny/api-core/features/security/teams/CreateTeam/index.js\";\nimport { descriptionOnCreate } from \"@webiny/api-core/features/security/shared/index.js\";\n\nconst inputSchema = z.object({\n    name: z.string().describe(\"Human-readable team name, e.g. 'Marketing'.\"),\n    slug: z\n        .string()\n        .describe(\"URL-safe identifier, e.g. 'marketing'. Lowercase, hyphens instead of spaces.\"),\n    /*\n     * Optional and capped, mirroring the use case's own schema. Requiring it made the model invent a\n     * description for every team; `CreateTeam` treats an absent one as empty via `descriptionOnCreate`.\n     */\n    description: z\n        .string()\n        .max(500)\n        .optional()\n        .describe(\"What the team is for. Shown in the admin UI. Omit it if the user did not say.\"),\n    roles: z\n        .array(z.string())\n        .describe(\n            \"Roles from listRoles. Prefer the `id`; a `slug` is accepted and resolved for you. Resolve them with listRoles first, since an unknown value is rejected rather than stored.\"\n        )\n});\n\ntype Input = z.infer<typeof inputSchema>;\n\ninterface CreatedTeam {\n    id: string;\n    name: string;\n    slug: string;\n    roles: string[];\n}\n\n/**\n * Creates a team.\n *\n * Not read-only, so it needs approval: a team is an access-control object, and the roles it carries\n * decide what its members can do. The user should see which roles are being granted before it exists.\n */\nclass CreateTeamToolImpl implements IAiSdkTool<Input> {\n    readonly name = \"createTeam\";\n    readonly title = \"Create team\";\n    readonly description =\n        \"Creates a team with a set of roles. Call listRoles first and pass what it returns; do not guess role identifiers. Requires user approval.\";\n    readonly inputSchema = inputSchema;\n    readonly annotations = { readOnlyHint: false };\n\n    constructor(private createTeam: CreateTeam.Interface) {}\n\n    async execute(input: Input): Promise<CreatedTeam> {\n        /*\n         * Roles go through untouched. `CreateTeam` accepts a role id or a slug and resolves either to\n         * the id a team stores, so the tool has nothing to add: doing it here too would read the roles\n         * a second time and leave two copies of the same rule to keep in step.\n         */\n        const result = await this.createTeam.execute({\n            name: input.name,\n            slug: input.slug,\n            // An omitted description becomes \"\", the same mapping the use case applies to its own input.\n            description: descriptionOnCreate(input.description),\n            roles: input.roles\n        });\n\n        if (result.isFail()) {\n            throw new Error(`Could not create the team: ${result.error.message}`);\n        }\n\n        const team = result.value;\n\n        return {\n            id: team.id,\n            name: team.name,\n            slug: team.slug,\n            // From the created team, so the caller sees the resolved ids that were actually stored.\n            roles: team.roles\n        };\n    }\n}\n\nexport const CreateTeamTool = AiSdkTool.createImplementation({\n    implementation: CreateTeamToolImpl,\n    dependencies: [CreateTeam]\n});\n"],"names":["inputSchema","z","CreateTeamToolImpl","createTeam","input","result","descriptionOnCreate","Error","team","CreateTeamTool","AiSdkTool","CreateTeam"],"mappings":";;;;AAMA,MAAMA,cAAcC,EAAE,MAAM,CAAC;IACzB,MAAMA,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC1B,MAAMA,EAAAA,MACK,GACN,QAAQ,CAAC;IAKd,aAAaA,EAAAA,MACF,GACN,GAAG,CAAC,KACJ,QAAQ,GACR,QAAQ,CAAC;IACd,OAAOA,EAAAA,KACG,CAACA,EAAE,MAAM,IACd,QAAQ,CACL;AAEZ;AAiBA,MAAMC;IAQF,YAAoBC,UAAgC,CAAE;aAAlCA,UAAU,GAAVA;aAPX,IAAI,GAAG;aACP,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAGH;aACd,WAAW,GAAG;YAAE,cAAc;QAAM;IAEU;IAEvD,MAAM,QAAQI,KAAY,EAAwB;QAM9C,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YACzC,MAAMD,MAAM,IAAI;YAChB,MAAMA,MAAM,IAAI;YAEhB,aAAaE,oBAAoBF,MAAM,WAAW;YAClD,OAAOA,MAAM,KAAK;QACtB;QAEA,IAAIC,OAAO,MAAM,IACb,MAAM,IAAIE,MAAM,CAAC,2BAA2B,EAAEF,OAAO,KAAK,CAAC,OAAO,EAAE;QAGxE,MAAMG,OAAOH,OAAO,KAAK;QAEzB,OAAO;YACH,IAAIG,KAAK,EAAE;YACX,MAAMA,KAAK,IAAI;YACf,MAAMA,KAAK,IAAI;YAEf,OAAOA,KAAK,KAAK;QACrB;IACJ;AACJ;AAEO,MAAMC,iBAAiBC,UAAU,oBAAoB,CAAC;IACzD,gBAAgBR;IAChB,cAAc;QAACS;KAAW;AAC9B"}

package/features/ai/GrantFolderAccessTool.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import type { IAiSdkTool } from "@webiny/api-core/features/ai/index.js";
+import { ListTeamsUseCase } from "@webiny/api-core/features/security/teams/ListTeams/index.js";
+import { GetFolderUseCase } from "../../features/folder/GetFolder/index.js";
+import { UpdateFolderUseCase } from "../../features/folder/UpdateFolder/index.js";
+declare const inputSchema: z.ZodObject<{
+    folderId: z.ZodString;
+    target: z.ZodString;
+    level: z.ZodEnum<{
+        editor: "editor";
+        "no-access": "no-access";
+        owner: "owner";
+        public: "public";
+        viewer: "viewer";
+    }>;
+}, z.core.$strip>;
+type Input = z.infer<typeof inputSchema>;
+interface GrantResult {
+    folderId: string;
+    title: string;
+    path: string;
+    /**
+     * Every direct rule on the folder afterwards.
+     *
+     * This is the set the update was asked to store, not an independent read of it:
+     * `UpdateFolderWithFolderLevelPermissions` returns the permissions it derived from the input
+     * rather than the ones the repository wrote. Treating it as a verification would let the tool
+     * confirm its own request back to itself.
+     */
+    permissions: {
+        target: string;
+        level: string;
+    }[];
+    /** True when the target already had a direct rule and its level was changed. */
+    replacedExistingLevel?: string;
+}
+/**
+ * Grants one target access to one folder, leaving every other rule alone.
+ *
+ * Additive by design. The earlier tool took the complete permission set and replaced it, which meant
+ * approving a change showed what would be SET and said nothing about what would be removed — a rule
+ * the model omitted disappeared silently. One target per call keeps the approval honest: what the user
+ * sees in the plan is the whole change.
+ */
+declare class GrantFolderAccessToolImpl implements IAiSdkTool<Input> {
+    private getFolder;
+    private updateFolder;
+    private listTeams;
+    readonly name = "grantFolderAccess";
+    readonly title = "Grant folder access";
+    readonly description = "Grants one team or user a level of access on one folder, leaving all other permissions untouched. Use listFolders for the folder id and listTeams for a team slug. Requires user approval.";
+    readonly inputSchema: z.ZodObject<{
+        folderId: z.ZodString;
+        target: z.ZodString;
+        level: z.ZodEnum<{
+            editor: "editor";
+            "no-access": "no-access";
+            owner: "owner";
+            public: "public";
+            viewer: "viewer";
+        }>;
+    }, z.core.$strip>;
+    readonly annotations: {
+        readOnlyHint: boolean;
+    };
+    constructor(getFolder: GetFolderUseCase.Interface, updateFolder: UpdateFolderUseCase.Interface, listTeams: ListTeamsUseCase.Interface);
+    execute(input: Input): Promise<GrantResult>;
+}
+export declare const GrantFolderAccessTool: typeof GrantFolderAccessToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IAiSdkTool<any>>;
+};
+export {};