@webiny/api-aco 0.0.0-unstable.d7f521b032 → 0.0.0-unstable.de38392959

package/filter/filter.model.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFilterModelDefinition = exports.FILTER_MODEL_ID = void 0;
+var _createModelField = require("../utils/createModelField");
+var _apiHeadlessCms = require("@webiny/api-headless-cms");
+const name = () => (0, _createModelField.createModelField)({
+  label: "Name",
+  fieldId: "name",
+  type: "text",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+const description = () => (0, _createModelField.createModelField)({
+  label: "Description",
+  fieldId: "description",
+  type: "text"
+});
+const namespace = () => (0, _createModelField.createModelField)({
+  label: "Model Id",
+  fieldId: "namespace",
+  type: "text",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+const operation = () => (0, _createModelField.createModelField)({
+  label: "Operation",
+  fieldId: "operation",
+  type: "text",
+  predefinedValues: {
+    enabled: true,
+    values: [{
+      label: "AND",
+      value: "AND"
+    }, {
+      label: "OR",
+      value: "OR"
+    }]
+  },
+  multipleValues: false,
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+const groups = fields => (0, _createModelField.createModelField)({
+  label: "Groups",
+  fieldId: "groups",
+  type: "object",
+  multipleValues: true,
+  settings: {
+    fields,
+    layout: fields.map(field => [field.storageId])
+  },
+  listValidation: [{
+    name: "minLength",
+    message: "At least one group is required.",
+    settings: {
+      value: "1"
+    }
+  }]
+});
+const filters = fields => (0, _createModelField.createModelField)({
+  label: "Filters",
+  fieldId: "filters",
+  type: "object",
+  multipleValues: true,
+  settings: {
+    fields,
+    layout: fields.map(field => [field.storageId])
+  },
+  listValidation: [{
+    name: "minLength",
+    message: "At least one filter is required.",
+    settings: {
+      value: "1"
+    }
+  }]
+});
+const field = () => (0, _createModelField.createModelField)({
+  label: "Field",
+  fieldId: "field",
+  type: "text",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+const condition = () => (0, _createModelField.createModelField)({
+  label: "Condition",
+  fieldId: "condition",
+  type: "text",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+const value = () => (0, _createModelField.createModelField)({
+  label: "Value",
+  fieldId: "value",
+  type: "text",
+  validation: [{
+    name: "required",
+    message: "Value is required."
+  }]
+});
+const FILTER_MODEL_ID = "acoFilter";
+exports.FILTER_MODEL_ID = FILTER_MODEL_ID;
+const createFilterModelDefinition = () => {
+  return (0, _apiHeadlessCms.createPrivateModelDefinition)({
+    name: "ACO - Filter",
+    modelId: FILTER_MODEL_ID,
+    titleFieldId: "name",
+    fields: [name(), description(), namespace(), operation(), groups([operation(), filters([field(), condition(), value()])])]
+  });
+};
+exports.createFilterModelDefinition = createFilterModelDefinition;
+
+//# sourceMappingURL=filter.model.js.map

package/filter/filter.model.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_createModelField","require","_apiHeadlessCms","name","createModelField","label","fieldId","type","validation","message","description","namespace","operation","predefinedValues","enabled","values","value","multipleValues","groups","fields","settings","layout","map","field","storageId","listValidation","filters","condition","FILTER_MODEL_ID","exports","createFilterModelDefinition","createPrivateModelDefinition","modelId","titleFieldId"],"sources":["filter.model.ts"],"sourcesContent":["import { createModelField } from \"~/utils/createModelField\";\nimport { createPrivateModelDefinition } from \"@webiny/api-headless-cms\";\nimport { CmsModelField } from \"@webiny/api-headless-cms/types\";\n\nconst name = () =>\n    createModelField({\n        label: \"Name\",\n        fieldId: \"name\",\n        type: \"text\",\n        validation: [\n            {\n                name: \"required\",\n                message: \"Value is required.\"\n            }\n        ]\n    });\n\nconst description = () =>\n    createModelField({\n        label: \"Description\",\n        fieldId: \"description\",\n        type: \"text\"\n    });\n\nconst namespace = () =>\n    createModelField({\n        label: \"Model Id\",\n        fieldId: \"namespace\",\n        type: \"text\",\n        validation: [\n            {\n                name: \"required\",\n                message: \"Value is required.\"\n            }\n        ]\n    });\n\nconst operation = () =>\n    createModelField({\n        label: \"Operation\",\n        fieldId: \"operation\",\n        type: \"text\",\n        predefinedValues: {\n            enabled: true,\n            values: [\n                {\n                    label: \"AND\",\n                    value: \"AND\"\n                },\n                {\n                    label: \"OR\",\n                    value: \"OR\"\n                }\n            ]\n        },\n        multipleValues: false,\n        validation: [\n            {\n                name: \"required\",\n                message: \"Value is required.\"\n            }\n        ]\n    });\n\nconst groups = (fields: CmsModelField[]) =>\n    createModelField({\n        label: \"Groups\",\n        fieldId: \"groups\",\n        type: \"object\",\n        multipleValues: true,\n        settings: {\n            fields,\n            layout: fields.map(field => [field.storageId])\n        },\n        listValidation: [\n            {\n                name: \"minLength\",\n                message: \"At least one group is required.\",\n                settings: {\n                    value: \"1\"\n                }\n            }\n        ]\n    });\n\nconst filters = (fields: CmsModelField[]) =>\n    createModelField({\n        label: \"Filters\",\n        fieldId: \"filters\",\n        type: \"object\",\n        multipleValues: true,\n        settings: {\n            fields,\n            layout: fields.map(field => [field.storageId])\n        },\n        listValidation: [\n            {\n                name: \"minLength\",\n                message: \"At least one filter is required.\",\n                settings: {\n                    value: \"1\"\n                }\n            }\n        ]\n    });\n\nconst field = () =>\n    createModelField({\n        label: \"Field\",\n        fieldId: \"field\",\n        type: \"text\",\n        validation: [\n            {\n                name: \"required\",\n                message: \"Value is required.\"\n            }\n        ]\n    });\n\nconst condition = () =>\n    createModelField({\n        label: \"Condition\",\n        fieldId: \"condition\",\n        type: \"text\",\n        validation: [\n            {\n                name: \"required\",\n                message: \"Value is required.\"\n            }\n        ]\n    });\n\nconst value = () =>\n    createModelField({\n        label: \"Value\",\n        fieldId: \"value\",\n        type: \"text\",\n        validation: [\n            {\n                name: \"required\",\n                message: \"Value is required.\"\n            }\n        ]\n    });\n\nexport const FILTER_MODEL_ID = \"acoFilter\";\n\nexport const createFilterModelDefinition = () => {\n    return createPrivateModelDefinition({\n        name: \"ACO - Filter\",\n        modelId: FILTER_MODEL_ID,\n        titleFieldId: \"name\",\n        fields: [\n            name(),\n            description(),\n            namespace(),\n            operation(),\n            groups([operation(), filters([field(), condition(), value()])])\n        ]\n    });\n};\n"],"mappings":"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"}

package/filter/filter.so.d.ts

@@ -0,0 +1,3 @@
+import { CreateAcoStorageOperationsParams } from "../createAcoStorageOperations";
+import { AcoFilterStorageOperations } from "./filter.types";
+export declare const createFilterOperations: (params: CreateAcoStorageOperationsParams) => AcoFilterStorageOperations;

package/filter/filter.so.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFilterOperations = void 0;
+var _omit = _interopRequireDefault(require("lodash/omit"));
+var _error = _interopRequireDefault(require("@webiny/error"));
+var _filter = require("./filter.model");
+var _createListSort = require("../utils/createListSort");
+var _createOperationsWrapper = require("../utils/createOperationsWrapper");
+var _pickEntryFieldValues = require("../utils/pickEntryFieldValues");
+var _constants = require("@webiny/api-headless-cms/constants");
+const createFilterOperations = params => {
+  const {
+    cms,
+    security
+  } = params;
+  const {
+    withModel
+  } = (0, _createOperationsWrapper.createOperationsWrapper)({
+    ...params,
+    modelName: _filter.FILTER_MODEL_ID
+  });
+  return {
+    getFilter({
+      id
+    }) {
+      return withModel(async model => {
+        const entry = await cms.getEntryById(model, id);
+        if (!entry) {
+          throw new _error.default("Could not load filter.", "GET_FILTER_ERROR", {
+            id
+          });
+        }
+        return (0, _pickEntryFieldValues.pickEntryFieldValues)(entry);
+      });
+    },
+    listFilters(params) {
+      return withModel(async model => {
+        const {
+          sort,
+          where
+        } = params;
+        const createdBy = security.getIdentity().id;
+        const [entries, meta] = await cms.listLatestEntries(model, {
+          ...params,
+          sort: (0, _createListSort.createListSort)(sort),
+          where: {
+            ...({
+              ...where,
+              createdBy
+            } || {})
+          }
+        });
+        return [entries.map(_pickEntryFieldValues.pickEntryFieldValues), meta];
+      });
+    },
+    createFilter({
+      data
+    }) {
+      return withModel(async model => {
+        const entry = await cms.createEntry(model, data);
+        return (0, _pickEntryFieldValues.pickEntryFieldValues)(entry);
+      });
+    },
+    updateFilter({
+      id,
+      data
+    }) {
+      return withModel(async model => {
+        const original = await cms.getEntryById(model, id);
+        const input = {
+          /**
+           *  We are omitting the standard entry meta fields:
+           *  we don't want to override them with the ones coming from the `original` entry.
+           */
+          ...(0, _omit.default)(original, _constants.ENTRY_META_FIELDS),
+          ...data
+        };
+        const entry = await cms.updateEntry(model, original.id, input);
+        return (0, _pickEntryFieldValues.pickEntryFieldValues)(entry);
+      });
+    },
+    deleteFilter({
+      id
+    }) {
+      return withModel(async model => {
+        await cms.deleteEntry(model, id);
+        return true;
+      });
+    }
+  };
+};
+exports.createFilterOperations = createFilterOperations;
+
+//# sourceMappingURL=filter.so.js.map

package/filter/filter.so.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_omit","_interopRequireDefault","require","_error","_filter","_createListSort","_createOperationsWrapper","_pickEntryFieldValues","_constants","createFilterOperations","params","cms","security","withModel","createOperationsWrapper","modelName","FILTER_MODEL_ID","getFilter","id","model","entry","getEntryById","WebinyError","pickEntryFieldValues","listFilters","sort","where","createdBy","getIdentity","entries","meta","listLatestEntries","createListSort","map","createFilter","data","createEntry","updateFilter","original","input","omit","ENTRY_META_FIELDS","updateEntry","deleteFilter","deleteEntry","exports"],"sources":["filter.so.ts"],"sourcesContent":["import omit from \"lodash/omit\";\nimport WebinyError from \"@webiny/error\";\nimport { FILTER_MODEL_ID } from \"./filter.model\";\nimport { CreateAcoStorageOperationsParams } from \"~/createAcoStorageOperations\";\nimport { createListSort } from \"~/utils/createListSort\";\nimport { createOperationsWrapper } from \"~/utils/createOperationsWrapper\";\nimport { pickEntryFieldValues } from \"~/utils/pickEntryFieldValues\";\nimport { AcoFilterStorageOperations, Filter } from \"./filter.types\";\nimport { ENTRY_META_FIELDS } from \"@webiny/api-headless-cms/constants\";\n\nexport const createFilterOperations = (\n    params: CreateAcoStorageOperationsParams\n): AcoFilterStorageOperations => {\n    const { cms, security } = params;\n\n    const { withModel } = createOperationsWrapper({\n        ...params,\n        modelName: FILTER_MODEL_ID\n    });\n\n    return {\n        getFilter({ id }) {\n            return withModel(async model => {\n                const entry = await cms.getEntryById(model, id);\n\n                if (!entry) {\n                    throw new WebinyError(\"Could not load filter.\", \"GET_FILTER_ERROR\", {\n                        id\n                    });\n                }\n\n                return pickEntryFieldValues(entry);\n            });\n        },\n        listFilters(params) {\n            return withModel(async model => {\n                const { sort, where } = params;\n                const createdBy = security.getIdentity().id;\n\n                const [entries, meta] = await cms.listLatestEntries(model, {\n                    ...params,\n                    sort: createListSort(sort),\n                    where: {\n                        ...({ ...where, createdBy } || {})\n                    }\n                });\n\n                return [entries.map(pickEntryFieldValues<Filter>), meta];\n            });\n        },\n        createFilter({ data }) {\n            return withModel(async model => {\n                const entry = await cms.createEntry(model, data);\n                return pickEntryFieldValues(entry);\n            });\n        },\n        updateFilter({ id, data }) {\n            return withModel(async model => {\n                const original = await cms.getEntryById(model, id);\n\n                const input = {\n                    /**\n                     *  We are omitting the standard entry meta fields:\n                     *  we don't want to override them with the ones coming from the `original` entry.\n                     */\n                    ...omit(original, ENTRY_META_FIELDS),\n                    ...data\n                };\n\n                const entry = await cms.updateEntry(model, original.id, input);\n                return pickEntryFieldValues(entry);\n            });\n        },\n        deleteFilter({ id }) {\n            return withModel(async model => {\n                await cms.deleteEntry(model, id);\n                return true;\n            });\n        }\n    };\n};\n"],"mappings":"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"}

package/filter/filter.types.d.ts

@@ -0,0 +1,95 @@
+import { AcoBaseFields, ListMeta, ListSort } from "../types";
+import { Topic } from "@webiny/pubsub/types";
+export declare enum Operation {
+    AND = "AND",
+    OR = "OR"
+}
+export interface GroupFilter {
+    field: string;
+    condition: string;
+    value: string;
+}
+export interface Group {
+    operation: Operation;
+    filters: GroupFilter[];
+}
+export interface Filter extends AcoBaseFields {
+    name: string;
+    description?: string;
+    namespace: string;
+    operation: Operation;
+    groups: Group[];
+}
+export interface ListFiltersWhere {
+    namespace: string;
+}
+export interface ListFiltersParams {
+    where: ListFiltersWhere;
+    sort?: ListSort;
+    limit?: number;
+    after?: string | null;
+}
+export declare type CreateFilterParams = Pick<Filter, "id" | "name" | "description" | "namespace" | "operation" | "groups">;
+export interface UpdateFilterParams {
+    name?: string;
+    description?: string;
+    namespace?: string;
+    operation?: Operation;
+    groups?: Group[];
+}
+export interface DeleteFilterParams {
+    id: string;
+}
+export interface StorageOperationsGetFilterParams {
+    id: string;
+}
+export declare type StorageOperationsListFiltersParams = ListFiltersParams;
+export interface StorageOperationsCreateFilterParams {
+    data: CreateFilterParams;
+}
+export interface StorageOperationsUpdateFilterParams {
+    id: string;
+    data: UpdateFilterParams;
+}
+export declare type StorageOperationsDeleteFilterParams = DeleteFilterParams;
+export interface OnFilterBeforeCreateTopicParams {
+    input: CreateFilterParams;
+}
+export interface OnFilterAfterCreateTopicParams {
+    filter: Filter;
+}
+export interface OnFilterBeforeUpdateTopicParams {
+    original: Filter;
+    input: Record<string, any>;
+}
+export interface OnFilterAfterUpdateTopicParams {
+    original: Filter;
+    filter: Filter;
+    input: Record<string, any>;
+}
+export interface OnFilterBeforeDeleteTopicParams {
+    filter: Filter;
+}
+export interface OnFilterAfterDeleteTopicParams {
+    filter: Filter;
+}
+export interface AcoFilterCrud {
+    get(id: string): Promise<Filter>;
+    list(params: ListFiltersParams): Promise<[Filter[], ListMeta]>;
+    create(data: CreateFilterParams): Promise<Filter>;
+    update(id: string, data: UpdateFilterParams): Promise<Filter>;
+    delete(id: string): Promise<boolean>;
+    onFilterBeforeCreate: Topic<OnFilterBeforeCreateTopicParams>;
+    onFilterAfterCreate: Topic<OnFilterAfterCreateTopicParams>;
+    onFilterBeforeUpdate: Topic<OnFilterBeforeUpdateTopicParams>;
+    onFilterAfterUpdate: Topic<OnFilterAfterUpdateTopicParams>;
+    onFilterBeforeDelete: Topic<OnFilterBeforeDeleteTopicParams>;
+    onFilterAfterDelete: Topic<OnFilterAfterDeleteTopicParams>;
+}
+export interface AcoFilterStorageOperations {
+    getFilter(params: StorageOperationsGetFilterParams): Promise<Filter>;
+    listFilters(params: StorageOperationsListFiltersParams): Promise<[Filter[], ListMeta]>;
+    createFilter(params: StorageOperationsCreateFilterParams): Promise<Filter>;
+    updateFilter(params: StorageOperationsUpdateFilterParams): Promise<Filter>;
+    deleteFilter(params: StorageOperationsDeleteFilterParams): Promise<boolean>;
+}

package/filter/filter.types.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Operation = void 0;
+let Operation = /*#__PURE__*/function (Operation) {
+  Operation["AND"] = "AND";
+  Operation["OR"] = "OR";
+  return Operation;
+}({});
+exports.Operation = Operation;
+
+//# sourceMappingURL=filter.types.js.map

package/filter/filter.types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Operation","exports"],"sources":["filter.types.ts"],"sourcesContent":["import { AcoBaseFields, ListMeta, ListSort } from \"~/types\";\nimport { Topic } from \"@webiny/pubsub/types\";\n\nexport enum Operation {\n    AND = \"AND\",\n    OR = \"OR\"\n}\n\nexport interface GroupFilter {\n    field: string;\n    condition: string;\n    value: string;\n}\n\nexport interface Group {\n    operation: Operation;\n    filters: GroupFilter[];\n}\n\nexport interface Filter extends AcoBaseFields {\n    name: string;\n    description?: string;\n    namespace: string;\n    operation: Operation;\n    groups: Group[];\n}\n\nexport interface ListFiltersWhere {\n    namespace: string;\n}\n\nexport interface ListFiltersParams {\n    where: ListFiltersWhere;\n    sort?: ListSort;\n    limit?: number;\n    after?: string | null;\n}\n\nexport type CreateFilterParams = Pick<\n    Filter,\n    \"id\" | \"name\" | \"description\" | \"namespace\" | \"operation\" | \"groups\"\n>;\n\nexport interface UpdateFilterParams {\n    name?: string;\n    description?: string;\n    namespace?: string;\n    operation?: Operation;\n    groups?: Group[];\n}\n\nexport interface DeleteFilterParams {\n    id: string;\n}\n\nexport interface StorageOperationsGetFilterParams {\n    id: string;\n}\n\nexport type StorageOperationsListFiltersParams = ListFiltersParams;\n\nexport interface StorageOperationsCreateFilterParams {\n    data: CreateFilterParams;\n}\n\nexport interface StorageOperationsUpdateFilterParams {\n    id: string;\n    data: UpdateFilterParams;\n}\n\nexport type StorageOperationsDeleteFilterParams = DeleteFilterParams;\n\nexport interface OnFilterBeforeCreateTopicParams {\n    input: CreateFilterParams;\n}\n\nexport interface OnFilterAfterCreateTopicParams {\n    filter: Filter;\n}\n\nexport interface OnFilterBeforeUpdateTopicParams {\n    original: Filter;\n    input: Record<string, any>;\n}\n\nexport interface OnFilterAfterUpdateTopicParams {\n    original: Filter;\n    filter: Filter;\n    input: Record<string, any>;\n}\n\nexport interface OnFilterBeforeDeleteTopicParams {\n    filter: Filter;\n}\n\nexport interface OnFilterAfterDeleteTopicParams {\n    filter: Filter;\n}\n\nexport interface AcoFilterCrud {\n    get(id: string): Promise<Filter>;\n    list(params: ListFiltersParams): Promise<[Filter[], ListMeta]>;\n    create(data: CreateFilterParams): Promise<Filter>;\n    update(id: string, data: UpdateFilterParams): Promise<Filter>;\n    delete(id: string): Promise<boolean>;\n    onFilterBeforeCreate: Topic<OnFilterBeforeCreateTopicParams>;\n    onFilterAfterCreate: Topic<OnFilterAfterCreateTopicParams>;\n    onFilterBeforeUpdate: Topic<OnFilterBeforeUpdateTopicParams>;\n    onFilterAfterUpdate: Topic<OnFilterAfterUpdateTopicParams>;\n    onFilterBeforeDelete: Topic<OnFilterBeforeDeleteTopicParams>;\n    onFilterAfterDelete: Topic<OnFilterAfterDeleteTopicParams>;\n}\n\nexport interface AcoFilterStorageOperations {\n    getFilter(params: StorageOperationsGetFilterParams): Promise<Filter>;\n    listFilters(params: StorageOperationsListFiltersParams): Promise<[Filter[], ListMeta]>;\n    createFilter(params: StorageOperationsCreateFilterParams): Promise<Filter>;\n    updateFilter(params: StorageOperationsUpdateFilterParams): Promise<Filter>;\n    deleteFilter(params: StorageOperationsDeleteFilterParams): Promise<boolean>;\n}\n"],"mappings":";;;;;;IAGYA,SAAS,0BAATA,SAAS;EAATA,SAAS;EAATA,SAAS;EAAA,OAATA,SAAS;AAAA;AAAAC,OAAA,CAAAD,SAAA,GAAAA,SAAA"}

package/folder/folder.crud.d.ts

@@ -1,3 +1,10 @@
 import { CreateAcoParams } from "../types";
 import { AcoFolderCrud } from "./folder.types";
-export declare const createFolderCrudMethods: ({ storageOperations }: CreateAcoParams) => AcoFolderCrud;
+import { AdminUser } from "@webiny/api-admin-users/types";
+import { Team } from "@webiny/api-security/types";
+interface CreateFolderCrudMethodsParams extends CreateAcoParams {
+    listAdminUsers: () => Promise<AdminUser[]>;
+    listTeams: () => Promise<Team[]>;
+}
+export declare const createFolderCrudMethods: ({ storageOperations, folderLevelPermissions, listAdminUsers, listTeams }: CreateFolderCrudMethodsParams) => AcoFolderCrud;
+export {};

package/folder/folder.crud.js

@@ -1,12 +1,21 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createFolderCrudMethods = void 0;
 var _pubsub = require("@webiny/pubsub");
+var _validation = require("@webiny/validation");
+var _getFolderAndItsAncestors = require("../utils/getFolderAndItsAncestors");
+var _NotAuthorizedError = _interopRequireDefault(require("@webiny/api-security/NotAuthorizedError"));
+var _error = _interopRequireDefault(require("@webiny/error"));
+const FIXED_FOLDER_LISTING_LIMIT = 10_000;
 const createFolderCrudMethods = ({
-  storageOperations
+  storageOperations,
+  folderLevelPermissions,
+  listAdminUsers,
+  listTeams
 }) => {
   // create
   const onFolderBeforeCreate = (0, _pubsub.createTopic)("aco.onFolderBeforeCreate");
@@ -28,20 +37,81 @@ const createFolderCrudMethods = ({
     onFolderBeforeDelete,
     onFolderAfterDelete,
     async get(id) {
-      return storageOperations.getFolder({
+      const folder = await storageOperations.getFolder({
         id
       });
+      await folderLevelPermissions.ensureCanAccessFolder({
+        folder,
+        rwd: "r"
+      });
+      await folderLevelPermissions.assignFolderPermissions(folder);
+      return folder;
     },
     async list(params) {
-      return storageOperations.listFolders(params);
+      // No matter what was the limit set in the params, initially, we always retrieve
+      // all folders. The limit is then applied with the filtered folders list below.
+      const filteredFolders = await folderLevelPermissions.listAllFoldersWithPermissions(params.where.type).then(filteredFolders => {
+        // If `parentId` was included in the `where` clause, we need to filter the folders.
+        // TODO: we might want to incorporate this into the `listAllFoldersWithPermissions` method.
+        if (params.where.parentId) {
+          // Filter by parent ID.
+          return filteredFolders.filter(folder => folder.parentId === params.where.parentId);
+        }
+        return filteredFolders;
+      });
+      const totalCount = filteredFolders.length;
+      let hasMoreItems = false;
+      let cursor = null;
+
+      // Apply cursor/limit params.
+      if (params.after) {
+        const afterListItemIndex = filteredFolders.findIndex(folder => folder.id === params.after);
+        if (afterListItemIndex >= 0) {
+          // Remove all items below the "after" item.
+          filteredFolders.splice(0, afterListItemIndex + 1);
+        }
+      }
+      hasMoreItems = !!params.limit && filteredFolders.length > params.limit;
+      if (hasMoreItems) {
+        cursor = filteredFolders[params.limit - 1]?.id || null;
+        filteredFolders.splice(params.limit);
+      }
+      return [filteredFolders, {
+        totalCount,
+        hasMoreItems,
+        cursor
+      }];
+    },
+    async listAll(params) {
+      return this.list({
+        ...params,
+        limit: FIXED_FOLDER_LISTING_LIMIT
+      });
     },
     async create(data) {
+      let canCreateFolder = false;
+      if (data.parentId) {
+        const parentFolder = await storageOperations.getFolder({
+          id: data.parentId
+        });
+        canCreateFolder = await folderLevelPermissions.canAccessFolder({
+          folder: parentFolder,
+          rwd: "w"
+        });
+      } else {
+        canCreateFolder = await folderLevelPermissions.canCreateFolderInRoot();
+      }
+      if (!canCreateFolder) {
+        throw new _NotAuthorizedError.default();
+      }
       await onFolderBeforeCreate.publish({
         input: data
       });
       const folder = await storageOperations.createFolder({
         data
       });
+      folderLevelPermissions.invalidateCache();
+      await folderLevelPermissions.assignFolderPermissions(folder);
       await onFolderAfterCreate.publish({
         folder
       });
@@ -51,6 +121,63 @@ const createFolderCrudMethods = ({
       const original = await storageOperations.getFolder({
         id
       });
+      const canUpdateFolder = await folderLevelPermissions.canAccessFolder({
+        folder: original,
+        rwd: "w"
+      });
+      if (!canUpdateFolder) {
+        throw new _NotAuthorizedError.default();
+      }
+
+      // Validate data.
+      if (Array.isArray(data.permissions)) {
+        data.permissions.forEach(permission => {
+          const targetIsValid = permission.target.startsWith("admin:") || permission.target.startsWith("team:");
+          if (!targetIsValid) {
+            throw new Error(`Permission target "${permission.target}" is not valid.`);
+          }
+          if (permission.inheritedFrom) {
+            throw new Error(`Permission "inheritedFrom" cannot be set manually.`);
+          }
+        });
+      }
+
+      // Parent change is not allowed if the user doesn't have access to the new parent.
+      if (data.parentId && data.parentId !== original.parentId) {
+        try {
+          // Getting the parent folder will throw an error if the user doesn't have access.
+          await this.get(data.parentId);
+        } catch (e) {
+          if (e instanceof _NotAuthorizedError.default) {
+            throw new _error.default(`Cannot move folder to a new parent because you don't have access to the new parent.`, "CANNOT_MOVE_FOLDER_TO_NEW_PARENT");
+          }
+
+          // If we didn't receive the expected error, we still want to throw it.
+          throw e;
+        }
+      }
+
+      // Let's prepare a custom folder permissions list, where the folder contains the updated data.
+      const customFoldersList = await folderLevelPermissions.listAllFolders(original.type).then(folders => {
+        const foldersClone = structuredClone(folders);
+        return foldersClone.map(folder => {
+          if (folder.id === id) {
+            Object.assign(folder, data);
+          }
+          return folder;
+        });
+      });
+      const stillHasAccess = await folderLevelPermissions.canAccessFolder({
+        folder: {
+          id,
+          type: original.type
+        },
+        rwd: "w",
+        foldersList: customFoldersList
+      });
+      if (!stillHasAccess) {
+        throw new _error.default(`Cannot continue because you would loose access to this folder.`, "CANNOT_LOOSE_FOLDER_ACCESS");
+      }
       await onFolderBeforeUpdate.publish({
         original,
         input: {
@@ -70,12 +197,18 @@ const createFolderCrudMethods = ({
         },
         folder
       });
+      folderLevelPermissions.invalidateCache();
+      await folderLevelPermissions.assignFolderPermissions(folder);
       return folder;
     },
     async delete(id) {
       const folder = await storageOperations.getFolder({
         id
       });
+      await folderLevelPermissions.ensureCanAccessFolder({
+        folder,
+        rwd: "d"
+      });
       await onFolderBeforeDelete.publish({
         folder
       });
@@ -86,7 +219,71 @@ const createFolderCrudMethods = ({
         folder
       });
       return true;
+    },
+    async getAncestors(folder) {
+      const [folders] = await this.listAll({
+        where: {
+          type: folder.type
+        }
+      });
+      return (0, _getFolderAndItsAncestors.getFolderAndItsAncestors)({
+        folder,
+        folders
+      });
+    },
+    /**
+     * @deprecated use `getAncestors` instead
+     */
+    async getFolderWithAncestors(id) {
+      const folder = await this.get(id);
+      return this.getAncestors(folder);
+    },
+    async listFolderLevelPermissionsTargets() {
+      const adminUsers = await listAdminUsers();
+      const teams = await listTeams();
+      const teamTargets = teams.map(team => ({
+        id: team.id,
+        type: "team",
+        target: `team:${team.id}`,
+        name: team.name || "",
+        meta: {}
+      }));
+      const adminUserTargets = adminUsers.map(user => {
+        let name = user.displayName;
+        if (!name) {
+          // For backwards compatibility, we also want to try concatenating first and last name.
+          name = [user.firstName, user.lastName].filter(Boolean).join(" ");
+        }
+
+        // We're doing the validation because, with non-Cognito IdPs (Okta, Auth0), the email
+        // field might actually contain a non-email value: `id:${IdP_Identity_ID}`. In that case,
+        // let's not assign anything to the `email` field.
+        let email = user.email;
+        try {
+          _validation.validation.validateSync(email, "email");
+        } catch {
+          email = null;
+        }
+        const image = user.avatar?.src || null;
+        return {
+          id: user.id,
+          type: "admin",
+          target: `admin:${user.id}`,
+          name,
+          meta: {
+            email,
+            image
+          }
+        };
+      });
+      const results = [...teamTargets, ...adminUserTargets];
+      const meta = {
+        totalCount: results.length
+      };
+      return [results, meta];
     }
   };
 };
-exports.createFolderCrudMethods = createFolderCrudMethods;
+exports.createFolderCrudMethods = createFolderCrudMethods;
+
+//# sourceMappingURL=folder.crud.js.map