@webiny/api-aco 0.0.0-unstable.496cf268ac → 0.0.0-unstable.5387e5f7c8

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

@@ -0,0 +1,77 @@
+import type { FolderAccessLevel, FolderPermission } from "../../../flp/flp.types.js";
+interface CodeTeamPermission {
+    /** Slug of the team the permission is granted to. */
+    team: string;
+    user?: never;
+    level: FolderAccessLevel;
+}
+interface CodeUserPermission {
+    /** ID of the admin user the permission is granted to. */
+    user: string;
+    team?: never;
+    level: FolderAccessLevel;
+}
+/**
+ * A permission grants a level to exactly one target: either a team or a single admin user. The
+ * `team:` / `admin:` target strings used internally are generated from these.
+ *
+ * Prefer `team` — team slugs are authored by hand and stable, while user IDs are generated at
+ * runtime and differ per environment.
+ */
+export type CodeFolderPermission = CodeTeamPermission | CodeUserPermission;
+export type CodeFlp = {
+    /**
+     * Folder type the rule applies to. Use `FlpFactory.FolderType` to build the built-in ones
+     * instead of writing the string by hand.
+     */
+    type: string;
+    /**
+     * Folder path the rule binds to. The leading `root` segment is optional, so both `/marketing`
+     * and `root/marketing` are accepted. A trailing `/*` matches the folder and its whole subtree.
+     */
+    path: string;
+    permissions: CodeFolderPermission[];
+};
+export interface IFlpFactory {
+    execute(): Promise<CodeFlp[]>;
+}
+/** Provide code-defined folder-level permissions. */
+export declare const FlpFactory: import("@webiny/di").Abstraction<IFlpFactory> & {
+    FolderType: {
+        /** File Manager folders. */
+        FileManager: {
+            /** Folders holding files. */
+            Files: string;
+        };
+        /** Headless CMS folders. */
+        Cms: {
+            /** Folders holding entries of a content model, addressed by its `modelId`. */
+            Entries(modelId: string): string;
+        };
+    };
+};
+export declare namespace FlpFactory {
+    type Interface = IFlpFactory;
+    type Return = Promise<CodeFlp[]>;
+    type Flp = CodeFlp;
+    type Permission = CodeFolderPermission;
+}
+export interface GetCodePermissionsParams {
+    type: string;
+    path: string;
+}
+export interface ICodeFlpsProvider {
+    /**
+     * Return all code-defined permissions that apply to the given folder type and path.
+     */
+    getPermissions(params: GetCodePermissionsParams): Promise<FolderPermission[]>;
+}
+/**
+ * Resolve code-defined folder-level permissions for a given folder. Only permissions contributed by
+ * an `FlpFactory` are considered — the ones stored in the database are loaded separately.
+ */
+export declare const CodeFlpsProvider: import("@webiny/di").Abstraction<ICodeFlpsProvider>;
+export declare namespace CodeFlpsProvider {
+    type Interface = ICodeFlpsProvider;
+}
+export {};

package/features/flp/shared/abstractions.js

@@ -0,0 +1,19 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { FM_FILE_TYPE } from "../../../constants.js";
+const FolderType = {
+    FileManager: {
+        Files: FM_FILE_TYPE
+    },
+    Cms: {
+        Entries (modelId) {
+            return `cms:${modelId}`;
+        }
+    }
+};
+const FlpFactory = Object.assign(createAbstraction("FlpFactory"), {
+    FolderType: FolderType
+});
+const CodeFlpsProvider = createAbstraction("CodeFlpsProvider");
+export { CodeFlpsProvider, FlpFactory };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/abstractions.js","sources":["../../../../src/features/flp/shared/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { FM_FILE_TYPE } from \"~/constants.js\";\nimport type { FolderAccessLevel, FolderPermission } from \"~/flp/flp.types.js\";\n\ninterface CodeTeamPermission {\n    /** Slug of the team the permission is granted to. */\n    team: string;\n    user?: never;\n    level: FolderAccessLevel;\n}\n\ninterface CodeUserPermission {\n    /** ID of the admin user the permission is granted to. */\n    user: string;\n    team?: never;\n    level: FolderAccessLevel;\n}\n\n/**\n * A permission grants a level to exactly one target: either a team or a single admin user. The\n * `team:` / `admin:` target strings used internally are generated from these.\n *\n * Prefer `team` — team slugs are authored by hand and stable, while user IDs are generated at\n * runtime and differ per environment.\n */\nexport type CodeFolderPermission = CodeTeamPermission | CodeUserPermission;\n\nexport type CodeFlp = {\n    /**\n     * Folder type the rule applies to. Use `FlpFactory.FolderType` to build the built-in ones\n     * instead of writing the string by hand.\n     */\n    type: string;\n    /**\n     * Folder path the rule binds to. The leading `root` segment is optional, so both `/marketing`\n     * and `root/marketing` are accepted. A trailing `/*` matches the folder and its whole subtree.\n     */\n    path: string;\n    permissions: CodeFolderPermission[];\n};\n\nexport interface IFlpFactory {\n    execute(): Promise<CodeFlp[]>;\n}\n\n/**\n * The folder types shipped with Webiny, grouped by the app that owns them, so `CodeFlp.type` does\n * not have to be written by hand.\n *\n * Folder types stay open-ended — every app registering folders picks its own type — so `type`\n * remains a plain `string` and a custom app can still pass its own value directly.\n */\nconst FolderType = {\n    /** File Manager folders. */\n    FileManager: {\n        /** Folders holding files. */\n        Files: FM_FILE_TYPE as string\n    },\n    /** Headless CMS folders. */\n    Cms: {\n        /** Folders holding entries of a content model, addressed by its `modelId`. */\n        Entries(modelId: string): string {\n            return `cms:${modelId}`;\n        }\n    }\n};\n\n/** Provide code-defined folder-level permissions. */\nexport const FlpFactory = Object.assign(createAbstraction<IFlpFactory>(\"FlpFactory\"), {\n    FolderType\n});\n\nexport namespace FlpFactory {\n    export type Interface = IFlpFactory;\n    export type Return = Promise<CodeFlp[]>;\n    export type Flp = CodeFlp;\n    export type Permission = CodeFolderPermission;\n}\n\nexport interface GetCodePermissionsParams {\n    type: string;\n    path: string;\n}\n\nexport interface ICodeFlpsProvider {\n    /**\n     * Return all code-defined permissions that apply to the given folder type and path.\n     */\n    getPermissions(params: GetCodePermissionsParams): Promise<FolderPermission[]>;\n}\n\n/**\n * Resolve code-defined folder-level permissions for a given folder. Only permissions contributed by\n * an `FlpFactory` are considered — the ones stored in the database are loaded separately.\n */\nexport const CodeFlpsProvider = createAbstraction<ICodeFlpsProvider>(\"CodeFlpsProvider\");\n\nexport namespace CodeFlpsProvider {\n    export type Interface = ICodeFlpsProvider;\n}\n"],"names":["FolderType","FM_FILE_TYPE","modelId","FlpFactory","Object","createAbstraction","CodeFlpsProvider"],"mappings":";;AAoDA,MAAMA,aAAa;IAEf,aAAa;QAET,OAAOC;IACX;IAEA,KAAK;QAED,SAAQC,OAAe;YACnB,OAAO,CAAC,IAAI,EAAEA,SAAS;QAC3B;IACJ;AACJ;AAGO,MAAMC,aAAaC,OAAO,MAAM,CAACC,kBAA+B,eAAe;IAClFL,YAAAA;AACJ;AAyBO,MAAMM,mBAAmBD,kBAAqC"}

package/features/flp/shared/feature.d.ts

@@ -0,0 +1,5 @@
+import { type Container } from "@webiny/feature/api";
+export declare const CodeFlpsFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/features/flp/shared/feature.js

@@ -0,0 +1,17 @@
+import { createFeature } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { CodeFlpsProvider } from "./CodeFlpsProvider.js";
+import { GetFlpWithCodeFlps } from "../GetFlp/decorators/GetFlpWithCodeFlps.js";
+import { ListFlpsWithCodeFlps } from "../ListFlps/decorators/ListFlpsWithCodeFlps.js";
+const CodeFlpsFeature = createFeature({
+    name: "CodeFlps",
+    register (container) {
+        if (!container.resolve(FeatureFlags).get().isEnabled("advancedAccessControlLayer.folderLevelPermissions")) return;
+        container.register(CodeFlpsProvider).inSingletonScope();
+        container.registerDecorator(GetFlpWithCodeFlps);
+        container.registerDecorator(ListFlpsWithCodeFlps);
+    }
+});
+export { CodeFlpsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/flp/shared/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/flp/shared/feature.js","sources":["../../../../src/features/flp/shared/feature.ts"],"sourcesContent":["import { type Container, createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { CodeFlpsProvider } from \"./CodeFlpsProvider.js\";\nimport { GetFlpWithCodeFlps } from \"~/features/flp/GetFlp/decorators/GetFlpWithCodeFlps.js\";\nimport { ListFlpsWithCodeFlps } from \"~/features/flp/ListFlps/decorators/ListFlpsWithCodeFlps.js\";\n\nexport const CodeFlpsFeature = createFeature({\n    name: \"CodeFlps\",\n    register(container: Container) {\n        // Code-defined FLPs are part of folder-level permissions, which is license-gated. Check at\n        // register time so nothing wires up — and no code permission is ever enforced — without the\n        // entitlement.\n        if (\n            !container\n                .resolve(FeatureFlags)\n                .get()\n                .isEnabled(\"advancedAccessControlLayer.folderLevelPermissions\")\n        ) {\n            return;\n        }\n\n        container.register(CodeFlpsProvider).inSingletonScope();\n        container.registerDecorator(GetFlpWithCodeFlps);\n        container.registerDecorator(ListFlpsWithCodeFlps);\n    }\n});\n"],"names":["CodeFlpsFeature","createFeature","container","FeatureFlags","CodeFlpsProvider","GetFlpWithCodeFlps","ListFlpsWithCodeFlps"],"mappings":";;;;;AAMO,MAAMA,kBAAkBC,cAAc;IACzC,MAAM;IACN,UAASC,SAAoB;QAIzB,IACI,CAACA,UACI,OAAO,CAACC,cACR,GAAG,GACH,SAAS,CAAC,sDAEf;QAGJD,UAAU,QAAQ,CAACE,kBAAkB,gBAAgB;QACrDF,UAAU,iBAAiB,CAACG;QAC5BH,UAAU,iBAAiB,CAACI;IAChC;AACJ"}

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

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./CodeFlpMerger.js";
+export * from "./CodeFlpPath.js";
+export * from "./CodeFlpTarget.js";

package/features/flp/shared/index.js

@@ -0,0 +1,4 @@
+export * from "./abstractions.js";
+export * from "./CodeFlpMerger.js";
+export * from "./CodeFlpPath.js";
+export * from "./CodeFlpTarget.js";

package/features/folder/CreateFolder/CreateFolderRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFolderRepository as RepositoryAbstraction, type ICreateFolderRepository } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import type { CreateFolderParams, Folder } from "../../../folder/folder.types.js";
+declare class CreateFolderRepositoryImpl implements ICreateFolderRepository {
+    private createEntry;
+    private listLatestEntries;
+    private getEntryById;
+    private folderModelProvider;
+    constructor(createEntry: CreateEntryUseCase.Interface, listLatestEntries: ListLatestEntriesUseCase.Interface, getEntryById: GetEntryByIdUseCase.Interface, folderModelProvider: FolderModelProvider.Interface);
+    execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>>;
+    private checkExistingFolder;
+    private createFolderPath;
+}
+export declare const CreateFolderRepository: typeof CreateFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<ICreateFolderRepository>;
+};
+export {};

package/features/folder/CreateFolder/CreateFolderRepository.js

@@ -0,0 +1,88 @@
+import { Result } from "@webiny/feature/api";
+import { CreateFolderRepository } from "./abstractions.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import { EntryToFolderMapper } from "../shared/EntryToFolderMapper.js";
+import { FolderPersistenceError, FolderValidationError } from "../../../domain/folder/errors.js";
+import { Path } from "../../../utils/Path.js";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+class CreateFolderRepositoryImpl {
+    constructor(createEntry, listLatestEntries, getEntryById, folderModelProvider){
+        this.createEntry = createEntry;
+        this.listLatestEntries = listLatestEntries;
+        this.getEntryById = getEntryById;
+        this.folderModelProvider = folderModelProvider;
+    }
+    async execute(data) {
+        const folderModel = await this.folderModelProvider.get();
+        const checkResult = await this.checkExistingFolder({
+            type: data.type,
+            slug: data.slug,
+            parentId: data.parentId
+        });
+        if (checkResult.isFail()) return Result.fail(checkResult.error);
+        const pathResult = await this.createFolderPath({
+            slug: data.slug,
+            parentId: data.parentId
+        });
+        if (pathResult.isFail()) return Result.fail(pathResult.error);
+        const result = await this.createEntry.execute(folderModel, {
+            values: {
+                ...data,
+                parentId: data.parentId || null,
+                path: pathResult.value
+            }
+        });
+        if (result.isFail()) {
+            if ("Cms/Entry/ValidationError" === result.error.code) return Result.fail(new FolderValidationError(result.error.message));
+            return Result.fail(new FolderPersistenceError(result.error));
+        }
+        const folder = EntryToFolderMapper.toFolder(result.value);
+        return Result.ok(folder);
+    }
+    async checkExistingFolder(params) {
+        const folderModel = await this.folderModelProvider.get();
+        const { type, slug, parentId, excludeId } = params;
+        const result = await this.listLatestEntries.execute(folderModel, {
+            where: {
+                latest: true,
+                values: {
+                    type,
+                    slug,
+                    parentId
+                },
+                ...excludeId ? {
+                    entryId_not: excludeId
+                } : {}
+            },
+            limit: 1
+        });
+        if (result.isFail()) return Result.fail(new FolderPersistenceError(result.error));
+        const { entries } = result.value;
+        if (entries.length > 0) return Result.fail(new FolderValidationError(`Folder with slug "${slug}" already exists at this level.`));
+        return Result.ok();
+    }
+    async createFolderPath(params) {
+        const folderModel = await this.folderModelProvider.get();
+        const { slug, parentId } = params;
+        if (!parentId) return Result.ok(Path.create(slug));
+        const parentResult = await this.getEntryById.execute(folderModel, EntryId.from(parentId).toString());
+        if (parentResult.isFail()) return Result.fail(new FolderPersistenceError(new Error("Parent folder not found. Unable to create the folder path")));
+        const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);
+        return Result.ok(Path.create(slug, parentFolder.path));
+    }
+}
+const CreateFolderRepository_CreateFolderRepository = CreateFolderRepository.createImplementation({
+    implementation: CreateFolderRepositoryImpl,
+    dependencies: [
+        CreateEntryUseCase,
+        ListLatestEntriesUseCase,
+        GetEntryByIdUseCase,
+        FolderModelProvider
+    ]
+});
+export { CreateFolderRepository_CreateFolderRepository as CreateFolderRepository };
+
+//# sourceMappingURL=CreateFolderRepository.js.map

package/features/folder/CreateFolder/CreateFolderRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/CreateFolderRepository.js","sources":["../../../../src/features/folder/CreateFolder/CreateFolderRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    CreateFolderRepository as RepositoryAbstraction,\n    type ICreateFolderRepository\n} from \"./abstractions.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById\";\nimport { FolderModelProvider } from \"~/domain/folder/abstractions.js\";\nimport type { CmsEntryFolder, CreateFolderParams, Folder } from \"~/folder/folder.types.js\";\nimport { EntryToFolderMapper } from \"../shared/EntryToFolderMapper.js\";\nimport { FolderPersistenceError, FolderValidationError } from \"~/domain/folder/errors.js\";\nimport { Path } from \"~/utils/Path.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nclass CreateFolderRepositoryImpl implements ICreateFolderRepository {\n    constructor(\n        private createEntry: CreateEntryUseCase.Interface,\n        private listLatestEntries: ListLatestEntriesUseCase.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private folderModelProvider: FolderModelProvider.Interface\n    ) {}\n\n    async execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\n        // Check if folder already exists\n        const checkResult = await this.checkExistingFolder({\n            type: data.type,\n            slug: data.slug,\n            parentId: data.parentId\n        });\n\n        if (checkResult.isFail()) {\n            return Result.fail(checkResult.error);\n        }\n\n        // Create folder path\n        const pathResult = await this.createFolderPath({\n            slug: data.slug,\n            parentId: data.parentId\n        });\n\n        if (pathResult.isFail()) {\n            return Result.fail(pathResult.error);\n        }\n\n        // Create the entry\n        const result = await this.createEntry.execute<CmsEntryFolder>(folderModel, {\n            values: {\n                ...data,\n                parentId: data.parentId || null,\n                path: pathResult.value\n            }\n        });\n\n        if (result.isFail()) {\n            if (result.error.code === \"Cms/Entry/ValidationError\") {\n                return Result.fail(new FolderValidationError(result.error.message));\n            }\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const folder = EntryToFolderMapper.toFolder(result.value);\n        return Result.ok(folder);\n    }\n\n    private async checkExistingFolder(params: {\n        type: string;\n        slug: string;\n        parentId?: string | null;\n        excludeId?: string;\n    }): Promise<Result<void, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\n        const { type, slug, parentId, excludeId } = params;\n\n        const result = await this.listLatestEntries.execute<CmsEntryFolder>(folderModel, {\n            where: {\n                latest: true,\n                values: {\n                    type,\n                    slug,\n                    parentId\n                },\n                ...(excludeId ? { entryId_not: excludeId } : {})\n            },\n            limit: 1\n        });\n\n        if (result.isFail()) {\n            return Result.fail(new FolderPersistenceError(result.error));\n        }\n\n        const { entries } = result.value;\n\n        if (entries.length > 0) {\n            return Result.fail(\n                new FolderValidationError(\n                    `Folder with slug \"${slug}\" already exists at this level.`\n                )\n            );\n        }\n\n        return Result.ok();\n    }\n\n    private async createFolderPath(params: {\n        slug: string;\n        parentId?: string | null;\n    }): Promise<Result<string, RepositoryAbstraction.Error>> {\n        const folderModel = await this.folderModelProvider.get();\n        const { slug, parentId } = params;\n\n        if (!parentId) {\n            return Result.ok(Path.create(slug));\n        }\n\n        const parentResult = await this.getEntryById.execute<CmsEntryFolder>(\n            folderModel,\n            EntryId.from(parentId).toString()\n        );\n\n        if (parentResult.isFail()) {\n            return Result.fail(\n                new FolderPersistenceError(\n                    new Error(\"Parent folder not found. Unable to create the folder path\")\n                )\n            );\n        }\n\n        const parentFolder = EntryToFolderMapper.toFolder(parentResult.value);\n        return Result.ok(Path.create(slug, parentFolder.path));\n    }\n}\n\nexport const CreateFolderRepository = RepositoryAbstraction.createImplementation({\n    implementation: CreateFolderRepositoryImpl,\n    dependencies: [\n        CreateEntryUseCase,\n        ListLatestEntriesUseCase,\n        GetEntryByIdUseCase,\n        FolderModelProvider\n    ]\n});\n"],"names":["CreateFolderRepositoryImpl","createEntry","listLatestEntries","getEntryById","folderModelProvider","data","folderModel","checkResult","Result","pathResult","result","FolderValidationError","FolderPersistenceError","folder","EntryToFolderMapper","params","type","slug","parentId","excludeId","entries","Path","parentResult","EntryId","Error","parentFolder","CreateFolderRepository","RepositoryAbstraction","CreateEntryUseCase","ListLatestEntriesUseCase","GetEntryByIdUseCase","FolderModelProvider"],"mappings":";;;;;;;;;;AAeA,MAAMA;IACF,YACYC,WAAyC,EACzCC,iBAAqD,EACrDC,YAA2C,EAC3CC,mBAAkD,CAC5D;aAJUH,WAAW,GAAXA;aACAC,iBAAiB,GAAjBA;aACAC,YAAY,GAAZA;aACAC,mBAAmB,GAAnBA;IACT;IAEH,MAAM,QAAQC,IAAwB,EAAwD;QAC1F,MAAMC,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG;QAEtD,MAAMC,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC;YAC/C,MAAMF,KAAK,IAAI;YACf,MAAMA,KAAK,IAAI;YACf,UAAUA,KAAK,QAAQ;QAC3B;QAEA,IAAIE,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAIxC,MAAME,aAAa,MAAM,IAAI,CAAC,gBAAgB,CAAC;YAC3C,MAAMJ,KAAK,IAAI;YACf,UAAUA,KAAK,QAAQ;QAC3B;QAEA,IAAII,WAAW,MAAM,IACjB,OAAOD,OAAO,IAAI,CAACC,WAAW,KAAK;QAIvC,MAAMC,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAiBJ,aAAa;YACvE,QAAQ;gBACJ,GAAGD,IAAI;gBACP,UAAUA,KAAK,QAAQ,IAAI;gBAC3B,MAAMI,WAAW,KAAK;YAC1B;QACJ;QAEA,IAAIC,OAAO,MAAM,IAAI;YACjB,IAAIA,AAAsB,gCAAtBA,OAAO,KAAK,CAAC,IAAI,EACjB,OAAOF,OAAO,IAAI,CAAC,IAAIG,sBAAsBD,OAAO,KAAK,CAAC,OAAO;YAErE,OAAOF,OAAO,IAAI,CAAC,IAAII,uBAAuBF,OAAO,KAAK;QAC9D;QAEA,MAAMG,SAASC,oBAAoB,QAAQ,CAACJ,OAAO,KAAK;QACxD,OAAOF,OAAO,EAAE,CAACK;IACrB;IAEA,MAAc,oBAAoBE,MAKjC,EAAsD;QACnD,MAAMT,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG;QACtD,MAAM,EAAEU,IAAI,EAAEC,IAAI,EAAEC,QAAQ,EAAEC,SAAS,EAAE,GAAGJ;QAE5C,MAAML,SAAS,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAiBJ,aAAa;YAC7E,OAAO;gBACH,QAAQ;gBACR,QAAQ;oBACJU;oBACAC;oBACAC;gBACJ;gBACA,GAAIC,YAAY;oBAAE,aAAaA;gBAAU,IAAI,CAAC,CAAC;YACnD;YACA,OAAO;QACX;QAEA,IAAIT,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAAC,IAAII,uBAAuBF,OAAO,KAAK;QAG9D,MAAM,EAAEU,OAAO,EAAE,GAAGV,OAAO,KAAK;QAEhC,IAAIU,QAAQ,MAAM,GAAG,GACjB,OAAOZ,OAAO,IAAI,CACd,IAAIG,sBACA,CAAC,kBAAkB,EAAEM,KAAK,+BAA+B,CAAC;QAKtE,OAAOT,OAAO,EAAE;IACpB;IAEA,MAAc,iBAAiBO,MAG9B,EAAwD;QACrD,MAAMT,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAAC,GAAG;QACtD,MAAM,EAAEW,IAAI,EAAEC,QAAQ,EAAE,GAAGH;QAE3B,IAAI,CAACG,UACD,OAAOV,OAAO,EAAE,CAACa,KAAK,MAAM,CAACJ;QAGjC,MAAMK,eAAe,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAChDhB,aACAiB,QAAQ,IAAI,CAACL,UAAU,QAAQ;QAGnC,IAAII,aAAa,MAAM,IACnB,OAAOd,OAAO,IAAI,CACd,IAAII,uBACA,IAAIY,MAAM;QAKtB,MAAMC,eAAeX,oBAAoB,QAAQ,CAACQ,aAAa,KAAK;QACpE,OAAOd,OAAO,EAAE,CAACa,KAAK,MAAM,CAACJ,MAAMQ,aAAa,IAAI;IACxD;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAA0C,CAAC;IAC7E,gBAAgB3B;IAChB,cAAc;QACV4B;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/folder/CreateFolder/CreateFolderUseCase.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher as EventPublisherAbstraction } from "@webiny/api-core/features/eventPublisher/index.js";
+import { CreateFolderUseCase as UseCaseAbstraction, CreateFolderRepository } from "./abstractions.js";
+import type { Folder, CreateFolderParams } from "../../../folder/folder.types.js";
+declare class CreateFolderUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private repository;
+    constructor(eventPublisher: EventPublisherAbstraction.Interface, repository: CreateFolderRepository.Interface);
+    execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseAbstraction.Error>>;
+}
+export declare const CreateFolderUseCase: import("@webiny/di").Implementation<typeof CreateFolderUseCaseImpl>;
+export {};

package/features/folder/CreateFolder/CreateFolderUseCase.js

@@ -0,0 +1,36 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { createImplementation } from "@webiny/di";
+import { CreateFolderRepository, CreateFolderUseCase } from "./abstractions.js";
+import { FolderAfterCreateEvent, FolderBeforeCreateEvent } from "./events.js";
+class CreateFolderUseCaseImpl {
+    constructor(eventPublisher, repository){
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+    }
+    async execute(params) {
+        const beforeCreateEvent = new FolderBeforeCreateEvent({
+            input: params
+        });
+        await this.eventPublisher.publish(beforeCreateEvent);
+        const result = await this.repository.execute(params);
+        if (result.isFail()) return result;
+        const folder = result.value;
+        const afterCreateEvent = new FolderAfterCreateEvent({
+            folder
+        });
+        await this.eventPublisher.publish(afterCreateEvent);
+        return Result.ok(folder);
+    }
+}
+const CreateFolderUseCase_CreateFolderUseCase = createImplementation({
+    abstraction: CreateFolderUseCase,
+    implementation: CreateFolderUseCaseImpl,
+    dependencies: [
+        EventPublisher,
+        CreateFolderRepository
+    ]
+});
+export { CreateFolderUseCase_CreateFolderUseCase as CreateFolderUseCase };
+
+//# sourceMappingURL=CreateFolderUseCase.js.map

package/features/folder/CreateFolder/CreateFolderUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/CreateFolderUseCase.js","sources":["../../../../src/features/folder/CreateFolder/CreateFolderUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport {\n    EventPublisher,\n    EventPublisher as EventPublisherAbstraction\n} from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { createImplementation } from \"@webiny/di\";\nimport {\n    CreateFolderUseCase as UseCaseAbstraction,\n    CreateFolderRepository\n} from \"./abstractions.js\";\nimport { FolderBeforeCreateEvent, FolderAfterCreateEvent } from \"./events.js\";\nimport type { Folder, CreateFolderParams } from \"~/folder/folder.types.js\";\n\nclass CreateFolderUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private eventPublisher: EventPublisherAbstraction.Interface,\n        private repository: CreateFolderRepository.Interface\n    ) {}\n\n    async execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseAbstraction.Error>> {\n        // Publish before create event\n        const beforeCreateEvent = new FolderBeforeCreateEvent({\n            input: params\n        });\n\n        await this.eventPublisher.publish(beforeCreateEvent);\n\n        // Execute the create operation\n        const result = await this.repository.execute(params);\n\n        if (result.isFail()) {\n            return result;\n        }\n\n        const folder = result.value;\n\n        // Publish after create event\n        const afterCreateEvent = new FolderAfterCreateEvent({\n            folder\n        });\n\n        await this.eventPublisher.publish(afterCreateEvent);\n\n        return Result.ok(folder);\n    }\n}\n\nexport const CreateFolderUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: CreateFolderUseCaseImpl,\n    dependencies: [EventPublisher, CreateFolderRepository]\n});\n"],"names":["CreateFolderUseCaseImpl","eventPublisher","repository","params","beforeCreateEvent","FolderBeforeCreateEvent","result","folder","afterCreateEvent","FolderAfterCreateEvent","Result","CreateFolderUseCase","createImplementation","UseCaseAbstraction","EventPublisher","CreateFolderRepository"],"mappings":";;;;;AAaA,MAAMA;IACF,YACYC,cAAmD,EACnDC,UAA4C,CACtD;aAFUD,cAAc,GAAdA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,MAA0B,EAAqD;QAEzF,MAAMC,oBAAoB,IAAIC,wBAAwB;YAClD,OAAOF;QACX;QAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACC;QAGlC,MAAME,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACH;QAE7C,IAAIG,OAAO,MAAM,IACb,OAAOA;QAGX,MAAMC,SAASD,OAAO,KAAK;QAG3B,MAAME,mBAAmB,IAAIC,uBAAuB;YAChDF;QACJ;QAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACC;QAElC,OAAOE,OAAO,EAAE,CAACH;IACrB;AACJ;AAEO,MAAMI,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBb;IAChB,cAAc;QAACc;QAAgBC;KAAuB;AAC1D"}

package/features/folder/CreateFolder/abstractions.d.ts

@@ -0,0 +1,59 @@
+import type { Result } from "@webiny/feature/api";
+import type { DomainEvent, IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { Folder, CreateFolderParams } from "../../../folder/folder.types.js";
+import type { FolderNotAuthorizedError, FolderPersistenceError, FolderValidationError } from "../../../domain/folder/errors.js";
+/**
+ * CreateFolder repository interface
+ */
+export interface ICreateFolderRepository {
+    execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryError>>;
+}
+export interface ICreateFolderRepositoryErrors {
+    validation: FolderValidationError;
+    persistence: FolderPersistenceError;
+}
+type RepositoryError = ICreateFolderRepositoryErrors[keyof ICreateFolderRepositoryErrors];
+/** Persist a newly created folder. */
+export declare const CreateFolderRepository: import("@webiny/di").Abstraction<ICreateFolderRepository>;
+export declare namespace CreateFolderRepository {
+    type Interface = ICreateFolderRepository;
+    type Error = RepositoryError;
+}
+/**
+ * CreateFolder use case interface
+ */
+export interface ICreateFolderUseCase {
+    execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseError>>;
+}
+export interface ICreateFolderUseCaseErrors {
+    notAuthorized: FolderNotAuthorizedError;
+    persistence: FolderPersistenceError;
+    validation: FolderValidationError;
+}
+type UseCaseError = ICreateFolderUseCaseErrors[keyof ICreateFolderUseCaseErrors];
+/** Create a new folder. */
+export declare const CreateFolderUseCase: import("@webiny/di").Abstraction<ICreateFolderUseCase>;
+export declare namespace CreateFolderUseCase {
+    type Interface = ICreateFolderUseCase;
+    type Return = Promise<Result<Folder, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export interface FolderBeforeCreatePayload {
+    input: CreateFolderParams;
+}
+export interface FolderAfterCreatePayload {
+    folder: Folder;
+}
+/** Hook into folder lifecycle before a folder is created. */
+export declare const FolderBeforeCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderBeforeCreatePayload>>>;
+export declare namespace FolderBeforeCreateEventHandler {
+    type Interface = IEventHandler<DomainEvent<FolderBeforeCreatePayload>>;
+    type Event = DomainEvent<FolderBeforeCreatePayload>;
+}
+/** Hook into folder lifecycle after a folder is created. */
+export declare const FolderAfterCreateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<FolderAfterCreatePayload>>>;
+export declare namespace FolderAfterCreateEventHandler {
+    type Interface = IEventHandler<DomainEvent<FolderAfterCreatePayload>>;
+    type Event = DomainEvent<FolderAfterCreatePayload>;
+}
+export {};

package/features/folder/CreateFolder/abstractions.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+const CreateFolderRepository = createAbstraction("CreateFolderRepository");
+const CreateFolderUseCase = createAbstraction("CreateFolderUseCase");
+const FolderBeforeCreateEventHandler = createAbstraction("FolderBeforeCreateEventHandler");
+const FolderAfterCreateEventHandler = createAbstraction("FolderAfterCreateEventHandler");
+export { CreateFolderRepository, CreateFolderUseCase, FolderAfterCreateEventHandler, FolderBeforeCreateEventHandler };
+
+//# sourceMappingURL=abstractions.js.map

package/features/folder/CreateFolder/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/abstractions.js","sources":["../../../../src/features/folder/CreateFolder/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { DomainEvent, IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { Folder, CreateFolderParams } from \"~/folder/folder.types.js\";\nimport type {\n    FolderNotAuthorizedError,\n    FolderPersistenceError,\n    FolderValidationError\n} from \"~/domain/folder/errors.js\";\n\n/**\n * CreateFolder repository interface\n */\nexport interface ICreateFolderRepository {\n    execute(data: CreateFolderParams): Promise<Result<Folder, RepositoryError>>;\n}\n\nexport interface ICreateFolderRepositoryErrors {\n    validation: FolderValidationError;\n    persistence: FolderPersistenceError;\n}\n\ntype RepositoryError = ICreateFolderRepositoryErrors[keyof ICreateFolderRepositoryErrors];\n\n/** Persist a newly created folder. */\nexport const CreateFolderRepository =\n    createAbstraction<ICreateFolderRepository>(\"CreateFolderRepository\");\n\nexport namespace CreateFolderRepository {\n    export type Interface = ICreateFolderRepository;\n    export type Error = RepositoryError;\n}\n\n/**\n * CreateFolder use case interface\n */\nexport interface ICreateFolderUseCase {\n    execute(params: CreateFolderParams): Promise<Result<Folder, UseCaseError>>;\n}\n\nexport interface ICreateFolderUseCaseErrors {\n    notAuthorized: FolderNotAuthorizedError;\n    persistence: FolderPersistenceError;\n    validation: FolderValidationError;\n}\n\ntype UseCaseError = ICreateFolderUseCaseErrors[keyof ICreateFolderUseCaseErrors];\n\n/** Create a new folder. */\nexport const CreateFolderUseCase = createAbstraction<ICreateFolderUseCase>(\"CreateFolderUseCase\");\n\nexport namespace CreateFolderUseCase {\n    export type Interface = ICreateFolderUseCase;\n    export type Return = Promise<Result<Folder, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n// Event Payload Types\nexport interface FolderBeforeCreatePayload {\n    input: CreateFolderParams;\n}\n\nexport interface FolderAfterCreatePayload {\n    folder: Folder;\n}\n\n// Event Handler Abstractions\n/** Hook into folder lifecycle before a folder is created. */\nexport const FolderBeforeCreateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderBeforeCreatePayload>>\n>(\"FolderBeforeCreateEventHandler\");\n\nexport namespace FolderBeforeCreateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderBeforeCreatePayload>>;\n    export type Event = DomainEvent<FolderBeforeCreatePayload>;\n}\n\n/** Hook into folder lifecycle after a folder is created. */\nexport const FolderAfterCreateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<FolderAfterCreatePayload>>\n>(\"FolderAfterCreateEventHandler\");\n\nexport namespace FolderAfterCreateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<FolderAfterCreatePayload>>;\n    export type Event = DomainEvent<FolderAfterCreatePayload>;\n}\n"],"names":["CreateFolderRepository","createAbstraction","CreateFolderUseCase","FolderBeforeCreateEventHandler","FolderAfterCreateEventHandler"],"mappings":";AAyBO,MAAMA,yBACTC,kBAA2C;AAuBxC,MAAMC,sBAAsBD,kBAAwC;AAmBpE,MAAME,iCAAiCF,kBAE5C;AAQK,MAAMG,gCAAgCH,kBAE3C"}

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.d.ts

@@ -0,0 +1,19 @@
+import { FolderLevelPermissions } from "../../../../features/flp/FolderLevelPermissions/index.js";
+import { CreateFolderUseCase } from "../abstractions.js";
+import type { CreateFolderParams } from "../../../../folder/folder.types.js";
+import { CodeFlpsProvider } from "../../../../features/flp/shared/index.js";
+declare class CreateFolderWithFolderLevelPermissionsImpl implements CreateFolderUseCase.Interface {
+    private folderLevelPermissions;
+    private readonly decoretee;
+    private readonly codeFlpsProvider?;
+    constructor(folderLevelPermissions: FolderLevelPermissions.Interface, codeFlpsProvider: CodeFlpsProvider.Interface | undefined, decoretee: CreateFolderUseCase.Interface);
+    execute(params: CreateFolderParams): CreateFolderUseCase.Return;
+    /**
+     * Code-defined permissions are resolved from the folder's own type and path rather than the FLP
+     * catalog: the record for a folder this new is written by an event handler and may not exist
+     * yet. Without this the response would omit them until something refetched the folder.
+     */
+    private withCodePermissions;
+}
+export declare const CreateFolderWithFolderLevelPermissions: typeof CreateFolderWithFolderLevelPermissionsImpl;
+export {};

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js

@@ -0,0 +1,56 @@
+import { FolderLevelPermissions } from "../../../flp/FolderLevelPermissions/index.js";
+import { CreateFolderUseCase } from "../abstractions.js";
+import { Result, createDecorator } from "@webiny/feature/api";
+import { FolderNotAuthorizedError } from "../../../../domain/folder/errors.js";
+import { CodeFlpMerger, CodeFlpsProvider } from "../../../flp/shared/index.js";
+class CreateFolderWithFolderLevelPermissionsImpl {
+    constructor(folderLevelPermissions, codeFlpsProvider, decoretee){
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.codeFlpsProvider = codeFlpsProvider;
+        this.decoretee = decoretee;
+    }
+    async execute(params) {
+        let canCreateFolder;
+        if (params.parentId) {
+            const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(params.parentId);
+            canCreateFolder = await this.folderLevelPermissions.canAccessFolder({
+                permissions,
+                rwd: "w"
+            });
+        } else canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();
+        if (!canCreateFolder) return Result.fail(new FolderNotAuthorizedError());
+        const result = await this.decoretee.execute(params);
+        if (result.isFail()) return Result.fail(result.error);
+        const folder = result.value;
+        const permissions = await this.withCodePermissions(folder, folder?.permissions ?? []);
+        const permissionsWithDefaults = await this.folderLevelPermissions.getDefaultPermissions(permissions);
+        return Result.ok({
+            ...folder,
+            permissions: permissionsWithDefaults
+        });
+    }
+    async withCodePermissions(folder, permissions) {
+        if (!this.codeFlpsProvider) return permissions;
+        const codePermissions = await this.codeFlpsProvider.getPermissions({
+            type: folder.type,
+            path: folder.path
+        });
+        return CodeFlpMerger.mergePermissions(permissions, codePermissions);
+    }
+}
+const CreateFolderWithFolderLevelPermissions = createDecorator({
+    abstraction: CreateFolderUseCase,
+    decorator: CreateFolderWithFolderLevelPermissionsImpl,
+    dependencies: [
+        FolderLevelPermissions,
+        [
+            CodeFlpsProvider,
+            {
+                optional: true
+            }
+        ]
+    ]
+});
+export { CreateFolderWithFolderLevelPermissions };
+
+//# sourceMappingURL=CreateFolderWithFolderLevelPermissions.js.map

package/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.js","sources":["../../../../../src/features/folder/CreateFolder/decorators/CreateFolderWithFolderLevelPermissions.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"~/features/flp/FolderLevelPermissions/index.js\";\nimport { CreateFolderUseCase } from \"../abstractions.js\";\nimport type { CreateFolderParams } from \"~/folder/folder.types.js\";\nimport type { Folder } from \"~/folder/folder.types.js\";\nimport type { FolderPermission } from \"~/flp/flp.types.js\";\nimport { createDecorator, Result } from \"@webiny/feature/api\";\nimport { FolderNotAuthorizedError } from \"~/domain/folder/errors.js\";\nimport { CodeFlpMerger } from \"~/features/flp/shared/index.js\";\nimport { CodeFlpsProvider } from \"~/features/flp/shared/index.js\";\n\nclass CreateFolderWithFolderLevelPermissionsImpl implements CreateFolderUseCase.Interface {\n    private folderLevelPermissions: FolderLevelPermissions.Interface;\n    private readonly decoretee: CreateFolderUseCase.Interface;\n    private readonly codeFlpsProvider?: CodeFlpsProvider.Interface;\n\n    constructor(\n        folderLevelPermissions: FolderLevelPermissions.Interface,\n        codeFlpsProvider: CodeFlpsProvider.Interface | undefined,\n        decoretee: CreateFolderUseCase.Interface\n    ) {\n        this.folderLevelPermissions = folderLevelPermissions;\n        this.codeFlpsProvider = codeFlpsProvider;\n        this.decoretee = decoretee;\n    }\n\n    async execute(params: CreateFolderParams): CreateFolderUseCase.Return {\n        let canCreateFolder: boolean;\n        if (params.parentId) {\n            const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(\n                params.parentId\n            );\n            canCreateFolder = await this.folderLevelPermissions.canAccessFolder({\n                permissions,\n                rwd: \"w\"\n            });\n        } else {\n            canCreateFolder = this.folderLevelPermissions.canCreateFolderInRoot();\n        }\n\n        if (!canCreateFolder) {\n            return Result.fail(new FolderNotAuthorizedError());\n        }\n\n        const result = await this.decoretee.execute(params);\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        const folder = result.value;\n\n        const permissions = await this.withCodePermissions(folder, folder?.permissions ?? []);\n\n        // Let's set default permissions based on the current user.\n        const permissionsWithDefaults =\n            await this.folderLevelPermissions.getDefaultPermissions(permissions);\n\n        return Result.ok({\n            ...folder,\n            permissions: permissionsWithDefaults\n        });\n    }\n\n    /**\n     * Code-defined permissions are resolved from the folder's own type and path rather than the FLP\n     * catalog: the record for a folder this new is written by an event handler and may not exist\n     * yet. Without this the response would omit them until something refetched the folder.\n     */\n    private async withCodePermissions(\n        folder: Pick<Folder, \"type\" | \"path\">,\n        permissions: FolderPermission[]\n    ): Promise<FolderPermission[]> {\n        if (!this.codeFlpsProvider) {\n            return permissions;\n        }\n\n        const codePermissions = await this.codeFlpsProvider.getPermissions({\n            type: folder.type,\n            path: folder.path\n        });\n\n        return CodeFlpMerger.mergePermissions(permissions, codePermissions);\n    }\n}\n\nexport const CreateFolderWithFolderLevelPermissions = createDecorator({\n    abstraction: CreateFolderUseCase,\n    decorator: CreateFolderWithFolderLevelPermissionsImpl,\n    // `CodeFlpsProvider` is optional: `CodeFlpsFeature` does not register it unless the project has\n    // the folder-level permissions entitlement.\n    dependencies: [FolderLevelPermissions, [CodeFlpsProvider, { optional: true }]]\n});\n"],"names":["CreateFolderWithFolderLevelPermissionsImpl","folderLevelPermissions","codeFlpsProvider","decoretee","params","canCreateFolder","permissions","Result","FolderNotAuthorizedError","result","folder","permissionsWithDefaults","codePermissions","CodeFlpMerger","CreateFolderWithFolderLevelPermissions","createDecorator","CreateFolderUseCase","FolderLevelPermissions","CodeFlpsProvider"],"mappings":";;;;;AAUA,MAAMA;IAKF,YACIC,sBAAwD,EACxDC,gBAAwD,EACxDC,SAAwC,CAC1C;QACE,IAAI,CAAC,sBAAsB,GAAGF;QAC9B,IAAI,CAAC,gBAAgB,GAAGC;QACxB,IAAI,CAAC,SAAS,GAAGC;IACrB;IAEA,MAAM,QAAQC,MAA0B,EAA8B;QAClE,IAAIC;QACJ,IAAID,OAAO,QAAQ,EAAE;YACjB,MAAME,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAC3EF,OAAO,QAAQ;YAEnBC,kBAAkB,MAAM,IAAI,CAAC,sBAAsB,CAAC,eAAe,CAAC;gBAChEC;gBACA,KAAK;YACT;QACJ,OACID,kBAAkB,IAAI,CAAC,sBAAsB,CAAC,qBAAqB;QAGvE,IAAI,CAACA,iBACD,OAAOE,OAAO,IAAI,CAAC,IAAIC;QAG3B,MAAMC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAACL;QAE5C,IAAIK,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAGnC,MAAMC,SAASD,OAAO,KAAK;QAE3B,MAAMH,cAAc,MAAM,IAAI,CAAC,mBAAmB,CAACI,QAAQA,QAAQ,eAAe,EAAE;QAGpF,MAAMC,0BACF,MAAM,IAAI,CAAC,sBAAsB,CAAC,qBAAqB,CAACL;QAE5D,OAAOC,OAAO,EAAE,CAAC;YACb,GAAGG,MAAM;YACT,aAAaC;QACjB;IACJ;IAOA,MAAc,oBACVD,MAAqC,EACrCJ,WAA+B,EACJ;QAC3B,IAAI,CAAC,IAAI,CAAC,gBAAgB,EACtB,OAAOA;QAGX,MAAMM,kBAAkB,MAAM,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC;YAC/D,MAAMF,OAAO,IAAI;YACjB,MAAMA,OAAO,IAAI;QACrB;QAEA,OAAOG,cAAc,gBAAgB,CAACP,aAAaM;IACvD;AACJ;AAEO,MAAME,yCAAyCC,gBAAgB;IAClE,aAAaC;IACb,WAAWhB;IAGX,cAAc;QAACiB;QAAwB;YAACC;YAAkB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAClF"}

package/features/folder/CreateFolder/events.d.ts

@@ -0,0 +1,10 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { FolderBeforeCreatePayload, FolderAfterCreatePayload } from "./abstractions.js";
+export declare class FolderBeforeCreateEvent extends DomainEvent<FolderBeforeCreatePayload> {
+    eventType: "folder.beforeCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<FolderBeforeCreatePayload>>>;
+}
+export declare class FolderAfterCreateEvent extends DomainEvent<FolderAfterCreatePayload> {
+    eventType: "folder.afterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<DomainEvent<FolderAfterCreatePayload>>>;
+}

package/features/folder/CreateFolder/events.js

@@ -0,0 +1,21 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import { FolderAfterCreateEventHandler, FolderBeforeCreateEventHandler } from "./abstractions.js";
+class FolderBeforeCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return FolderBeforeCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "folder.beforeCreate";
+    }
+}
+class FolderAfterCreateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return FolderAfterCreateEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "folder.afterCreate";
+    }
+}
+export { FolderAfterCreateEvent, FolderBeforeCreateEvent };
+
+//# sourceMappingURL=events.js.map

package/features/folder/CreateFolder/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/events.js","sources":["../../../../src/features/folder/CreateFolder/events.ts"],"sourcesContent":["import { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { FolderBeforeCreateEventHandler, FolderAfterCreateEventHandler } from \"./abstractions.js\";\nimport type { FolderBeforeCreatePayload, FolderAfterCreatePayload } from \"./abstractions.js\";\n\n// FolderBeforeCreate Event\nexport class FolderBeforeCreateEvent extends DomainEvent<FolderBeforeCreatePayload> {\n    eventType = \"folder.beforeCreate\" as const;\n\n    getHandlerAbstraction() {\n        return FolderBeforeCreateEventHandler;\n    }\n}\n\n// FolderAfterCreate Event\nexport class FolderAfterCreateEvent extends DomainEvent<FolderAfterCreatePayload> {\n    eventType = \"folder.afterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return FolderAfterCreateEventHandler;\n    }\n}\n"],"names":["FolderBeforeCreateEvent","DomainEvent","FolderBeforeCreateEventHandler","FolderAfterCreateEvent","FolderAfterCreateEventHandler"],"mappings":";;AAKO,MAAMA,gCAAgCC;IAGzC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAGO,MAAMC,+BAA+BF;IAGxC,wBAAwB;QACpB,OAAOG;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

package/features/folder/CreateFolder/feature.d.ts

@@ -0,0 +1,5 @@
+import type { Container } from "@webiny/di";
+export declare const CreateFolderFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/features/folder/CreateFolder/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateFolderRepository } from "./CreateFolderRepository.js";
+import { CreateFolderUseCase } from "./CreateFolderUseCase.js";
+import { CreateFolderWithFolderLevelPermissions } from "./decorators/CreateFolderWithFolderLevelPermissions.js";
+const CreateFolderFeature = createFeature({
+    name: "CreateFolder",
+    register (container) {
+        container.register(CreateFolderRepository).inSingletonScope();
+        container.register(CreateFolderUseCase);
+        container.registerDecorator(CreateFolderWithFolderLevelPermissions);
+    }
+});
+export { CreateFolderFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/folder/CreateFolder/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/folder/CreateFolder/feature.js","sources":["../../../../src/features/folder/CreateFolder/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { CreateFolderRepository } from \"./CreateFolderRepository.js\";\nimport { CreateFolderUseCase } from \"./CreateFolderUseCase.js\";\nimport { CreateFolderWithFolderLevelPermissions } from \"./decorators/CreateFolderWithFolderLevelPermissions.js\";\n\nexport const CreateFolderFeature = createFeature({\n    name: \"CreateFolder\",\n    register(container: Container) {\n        container.register(CreateFolderRepository).inSingletonScope();\n        container.register(CreateFolderUseCase);\n        container.registerDecorator(CreateFolderWithFolderLevelPermissions);\n    }\n});\n"],"names":["CreateFolderFeature","createFeature","container","CreateFolderRepository","CreateFolderUseCase","CreateFolderWithFolderLevelPermissions"],"mappings":";;;;AAMO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC,wBAAwB,gBAAgB;QAC3DD,UAAU,QAAQ,CAACE;QACnBF,UAAU,iBAAiB,CAACG;IAChC;AACJ"}

package/features/folder/CreateFolder/index.d.ts

@@ -0,0 +1,2 @@
+export { CreateFolderFeature } from "./feature.js";
+export { FolderAfterCreateEventHandler, FolderBeforeCreateEventHandler, CreateFolderUseCase } from "./abstractions.js";

package/features/folder/CreateFolder/index.js

@@ -0,0 +1,2 @@
+export { CreateFolderFeature } from "./feature.js";
+export { CreateFolderUseCase, FolderAfterCreateEventHandler, FolderBeforeCreateEventHandler } from "./abstractions.js";

package/features/folder/DeleteFolder/DeleteFolderRepository.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteFolderRepository as RepositoryAbstraction, type IDeleteFolderRepository } from "./abstractions.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry";
+import { FolderModelProvider } from "../../../domain/folder/abstractions.js";
+import type { Folder } from "../../../folder/folder.types.js";
+declare class DeleteFolderRepositoryImpl implements IDeleteFolderRepository {
+    private deleteEntry;
+    private folderModelProvider;
+    constructor(deleteEntry: DeleteEntryUseCase.Interface, folderModelProvider: FolderModelProvider.Interface);
+    execute(folder: Folder): Promise<Result<void, RepositoryAbstraction.Error>>;
+}
+export declare const DeleteFolderRepository: typeof DeleteFolderRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IDeleteFolderRepository>;
+};
+export {};