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

package/filter/filter.gql.js

@@ -0,0 +1,164 @@
+import { ErrorResponse, ListResponse } from "@webiny/api-graphql/responses.js";
+import { ensureAuthentication } from "../utils/ensureAuthentication.js";
+import { resolve } from "../utils/resolve.js";
+import { AcoFilterCrud } from "../features/folder/shared/abstractions.js";
+const addFilterSchema = (builder)=>{
+    builder.addTypeDefs(`
+        enum OperationEnum {
+            AND
+            OR
+        }
+
+        type GroupFilter {
+            field: String!
+            condition: String!
+            value: String!
+        }
+
+        type Group {
+            operation: OperationEnum!
+            filters: [GroupFilter]!
+        }
+
+        type Filter {
+            id: ID!
+            name: String!
+            description: String
+            namespace: String!
+            operation: OperationEnum!
+            groups: [Group]!
+            createdOn: DateTime
+            modifiedOn: DateTime
+            savedOn: DateTime
+            createdBy: AcoUser
+            modifiedBy: AcoUser
+            savedBy: AcoUser
+        }
+
+        input GroupFilterInput {
+            field: String!
+            condition: String!
+            value: String!
+        }
+
+        input GroupInput {
+            operation: OperationEnum!
+            filters: [GroupFilterInput]!
+        }
+
+        input FilterCreateInput {
+            id: ID!
+            name: String!
+            description: String
+            namespace: String!
+            operation: OperationEnum!
+            groups: [GroupInput]!
+        }
+
+        input FilterUpdateInput {
+            name: String
+            description: String
+            namespace: String
+            operation: OperationEnum
+            groups: [GroupInput]
+        }
+
+        input FiltersListWhereInput {
+            namespace: String
+        }
+
+        type FilterResponse {
+            data: Filter
+            error: AcoError
+        }
+
+        type FilterListResponse {
+            data: [Filter]
+            error: AcoError
+        }
+
+        extend type AcoQuery {
+            getFilter(id: ID!): FilterResponse
+            listFilters(
+                where: FiltersListWhereInput!
+                limit: Int
+                after: String
+                sort: AcoSort
+            ): FilterListResponse
+        }
+
+        extend type AcoMutation {
+            createFilter(data: FilterCreateInput!): FilterResponse
+            updateFilter(id: ID!, data: FilterUpdateInput!): FilterResponse
+            deleteFilter(id: ID!): AcoBooleanResponse
+        }
+    `);
+    builder.addResolver({
+        path: "AcoQuery.getFilter",
+        dependencies: [
+            AcoFilterCrud
+        ],
+        resolver (filterCrud) {
+            return ({ args, context })=>resolve(()=>{
+                    ensureAuthentication(context);
+                    return filterCrud.get(args.id);
+                });
+        }
+    });
+    builder.addResolver({
+        path: "AcoQuery.listFilters",
+        dependencies: [
+            AcoFilterCrud
+        ],
+        resolver (filterCrud) {
+            return async ({ args, context })=>{
+                try {
+                    ensureAuthentication(context);
+                    const [entries, meta] = await filterCrud.list(args);
+                    return new ListResponse(entries, meta);
+                } catch (e) {
+                    return new ErrorResponse(e);
+                }
+            };
+        }
+    });
+    builder.addResolver({
+        path: "AcoMutation.createFilter",
+        dependencies: [
+            AcoFilterCrud
+        ],
+        resolver (filterCrud) {
+            return ({ args, context })=>resolve(()=>{
+                    ensureAuthentication(context);
+                    return filterCrud.create(args.data);
+                });
+        }
+    });
+    builder.addResolver({
+        path: "AcoMutation.updateFilter",
+        dependencies: [
+            AcoFilterCrud
+        ],
+        resolver (filterCrud) {
+            return ({ args, context })=>resolve(()=>{
+                    ensureAuthentication(context);
+                    return filterCrud.update(args.id, args.data);
+                });
+        }
+    });
+    builder.addResolver({
+        path: "AcoMutation.deleteFilter",
+        dependencies: [
+            AcoFilterCrud
+        ],
+        resolver (filterCrud) {
+            return ({ args, context })=>resolve(()=>{
+                    ensureAuthentication(context);
+                    return filterCrud.delete(args.id);
+                });
+        }
+    });
+};
+export { addFilterSchema };
+
+//# sourceMappingURL=filter.gql.js.map

package/filter/filter.gql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter/filter.gql.js","sources":["../../src/filter/filter.gql.ts"],"sourcesContent":["import { ErrorResponse, ListResponse } from \"@webiny/api-graphql/responses.js\";\nimport type { IGraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\nimport { ensureAuthentication } from \"~/utils/ensureAuthentication.js\";\nimport { resolve } from \"~/utils/resolve.js\";\nimport { AcoFilterCrud } from \"~/features/folder/shared/abstractions.js\";\n\nexport const addFilterSchema = (builder: IGraphQLSchemaBuilder): void => {\n    builder.addTypeDefs(/* GraphQL */ `\n        enum OperationEnum {\n            AND\n            OR\n        }\n\n        type GroupFilter {\n            field: String!\n            condition: String!\n            value: String!\n        }\n\n        type Group {\n            operation: OperationEnum!\n            filters: [GroupFilter]!\n        }\n\n        type Filter {\n            id: ID!\n            name: String!\n            description: String\n            namespace: String!\n            operation: OperationEnum!\n            groups: [Group]!\n            createdOn: DateTime\n            modifiedOn: DateTime\n            savedOn: DateTime\n            createdBy: AcoUser\n            modifiedBy: AcoUser\n            savedBy: AcoUser\n        }\n\n        input GroupFilterInput {\n            field: String!\n            condition: String!\n            value: String!\n        }\n\n        input GroupInput {\n            operation: OperationEnum!\n            filters: [GroupFilterInput]!\n        }\n\n        input FilterCreateInput {\n            id: ID!\n            name: String!\n            description: String\n            namespace: String!\n            operation: OperationEnum!\n            groups: [GroupInput]!\n        }\n\n        input FilterUpdateInput {\n            name: String\n            description: String\n            namespace: String\n            operation: OperationEnum\n            groups: [GroupInput]\n        }\n\n        input FiltersListWhereInput {\n            namespace: String\n        }\n\n        type FilterResponse {\n            data: Filter\n            error: AcoError\n        }\n\n        type FilterListResponse {\n            data: [Filter]\n            error: AcoError\n        }\n\n        extend type AcoQuery {\n            getFilter(id: ID!): FilterResponse\n            listFilters(\n                where: FiltersListWhereInput!\n                limit: Int\n                after: String\n                sort: AcoSort\n            ): FilterListResponse\n        }\n\n        extend type AcoMutation {\n            createFilter(data: FilterCreateInput!): FilterResponse\n            updateFilter(id: ID!, data: FilterUpdateInput!): FilterResponse\n            deleteFilter(id: ID!): AcoBooleanResponse\n        }\n    `);\n\n    builder.addResolver({\n        path: \"AcoQuery.getFilter\",\n        dependencies: [AcoFilterCrud],\n        resolver(filterCrud) {\n            return ({ args, context }) =>\n                resolve(() => {\n                    ensureAuthentication(context);\n                    return filterCrud.get(args.id);\n                });\n        }\n    });\n\n    builder.addResolver({\n        path: \"AcoQuery.listFilters\",\n        dependencies: [AcoFilterCrud],\n        resolver(filterCrud) {\n            return async ({ args, context }) => {\n                try {\n                    ensureAuthentication(context);\n                    const [entries, meta] = await filterCrud.list(args);\n                    return new ListResponse(entries, meta);\n                } catch (e) {\n                    return new ErrorResponse(e);\n                }\n            };\n        }\n    });\n\n    builder.addResolver({\n        path: \"AcoMutation.createFilter\",\n        dependencies: [AcoFilterCrud],\n        resolver(filterCrud) {\n            return ({ args, context }) =>\n                resolve(() => {\n                    ensureAuthentication(context);\n                    return filterCrud.create(args.data);\n                });\n        }\n    });\n\n    builder.addResolver({\n        path: \"AcoMutation.updateFilter\",\n        dependencies: [AcoFilterCrud],\n        resolver(filterCrud) {\n            return ({ args, context }) =>\n                resolve(() => {\n                    ensureAuthentication(context);\n                    return filterCrud.update(args.id, args.data);\n                });\n        }\n    });\n\n    builder.addResolver({\n        path: \"AcoMutation.deleteFilter\",\n        dependencies: [AcoFilterCrud],\n        resolver(filterCrud) {\n            return ({ args, context }) =>\n                resolve(() => {\n                    ensureAuthentication(context);\n                    return filterCrud.delete(args.id);\n                });\n        }\n    });\n};\n"],"names":["addFilterSchema","builder","AcoFilterCrud","filterCrud","args","context","resolve","ensureAuthentication","entries","meta","ListResponse","e","ErrorResponse"],"mappings":";;;;AAMO,MAAMA,kBAAkB,CAACC;IAC5BA,QAAQ,WAAW,CAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyFnC,CAAC;IAEDA,QAAQ,WAAW,CAAC;QAChB,MAAM;QACN,cAAc;YAACC;SAAc;QAC7B,UAASC,UAAU;YACf,OAAO,CAAC,EAAEC,IAAI,EAAEC,OAAO,EAAE,GACrBC,QAAQ;oBACJC,qBAAqBF;oBACrB,OAAOF,WAAW,GAAG,CAACC,KAAK,EAAE;gBACjC;QACR;IACJ;IAEAH,QAAQ,WAAW,CAAC;QAChB,MAAM;QACN,cAAc;YAACC;SAAc;QAC7B,UAASC,UAAU;YACf,OAAO,OAAO,EAAEC,IAAI,EAAEC,OAAO,EAAE;gBAC3B,IAAI;oBACAE,qBAAqBF;oBACrB,MAAM,CAACG,SAASC,KAAK,GAAG,MAAMN,WAAW,IAAI,CAACC;oBAC9C,OAAO,IAAIM,aAAaF,SAASC;gBACrC,EAAE,OAAOE,GAAG;oBACR,OAAO,IAAIC,cAAcD;gBAC7B;YACJ;QACJ;IACJ;IAEAV,QAAQ,WAAW,CAAC;QAChB,MAAM;QACN,cAAc;YAACC;SAAc;QAC7B,UAASC,UAAU;YACf,OAAO,CAAC,EAAEC,IAAI,EAAEC,OAAO,EAAE,GACrBC,QAAQ;oBACJC,qBAAqBF;oBACrB,OAAOF,WAAW,MAAM,CAACC,KAAK,IAAI;gBACtC;QACR;IACJ;IAEAH,QAAQ,WAAW,CAAC;QAChB,MAAM;QACN,cAAc;YAACC;SAAc;QAC7B,UAASC,UAAU;YACf,OAAO,CAAC,EAAEC,IAAI,EAAEC,OAAO,EAAE,GACrBC,QAAQ;oBACJC,qBAAqBF;oBACrB,OAAOF,WAAW,MAAM,CAACC,KAAK,EAAE,EAAEA,KAAK,IAAI;gBAC/C;QACR;IACJ;IAEAH,QAAQ,WAAW,CAAC;QAChB,MAAM;QACN,cAAc;YAACC;SAAc;QAC7B,UAASC,UAAU;YACf,OAAO,CAAC,EAAEC,IAAI,EAAEC,OAAO,EAAE,GACrBC,QAAQ;oBACJC,qBAAqBF;oBACrB,OAAOF,WAAW,MAAM,CAACC,KAAK,EAAE;gBACpC;QACR;IACJ;AACJ"}

package/filter/filter.model.d.ts

@@ -0,0 +1,9 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+export declare const FILTER_MODEL_ID: string;
+declare class FilterPrivateModelImpl implements ModelFactory.Interface {
+    execute(builder: ModelFactory.Builder): Promise<import("@webiny/api-headless-cms/features/modelBuilder/index.js").PrivateModelBuilder[]>;
+}
+export declare const FilterPrivateModel: typeof FilterPrivateModelImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/modelBuilder/abstractions").IModelFactory>;
+};
+export {};

package/filter/filter.model.js

@@ -0,0 +1,51 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+const FILTER_MODEL_ID = process.env.WEBINY_API_LEGACY_MODELS ? "acoFilter" : "wbyAcoFilter";
+class FilterPrivateModelImpl {
+    async execute(builder) {
+        return [
+            builder.private({
+                modelId: FILTER_MODEL_ID,
+                name: "ACO - Filter",
+                lifecycleEvents: false
+            }).fields((fields)=>({
+                    name: fields.text().label("Name").required(),
+                    description: fields.text().label("Description"),
+                    namespace: fields.text().label("Model Id").required(),
+                    operation: fields.text().label("Operation").required().predefinedValues([
+                        {
+                            label: "AND",
+                            value: "AND"
+                        },
+                        {
+                            label: "OR",
+                            value: "OR"
+                        }
+                    ]),
+                    groups: fields.object().label("Groups").list().listMinLength(1, "At least one group is required.").fields((fields)=>({
+                            operation: fields.text().label("Operation").required().predefinedValues([
+                                {
+                                    label: "AND",
+                                    value: "AND"
+                                },
+                                {
+                                    label: "OR",
+                                    value: "OR"
+                                }
+                            ]),
+                            filters: fields.object().label("Filters").list().listMinLength(1, "At least one filter is required.").fields((filterFields)=>({
+                                    field: filterFields.text().label("Field").required(),
+                                    condition: filterFields.text().label("Condition").required(),
+                                    value: filterFields.text().label("Value").required()
+                                }))
+                        }))
+                }))
+        ];
+    }
+}
+const FilterPrivateModel = ModelFactory.createImplementation({
+    implementation: FilterPrivateModelImpl,
+    dependencies: []
+});
+export { FILTER_MODEL_ID, FilterPrivateModel };
+
+//# sourceMappingURL=filter.model.js.map

package/filter/filter.model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter/filter.model.js","sources":["../../src/filter/filter.model.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\n\nexport const FILTER_MODEL_ID = process.env.WEBINY_API_LEGACY_MODELS ? \"acoFilter\" : \"wbyAcoFilter\";\n\nclass FilterPrivateModelImpl implements ModelFactory.Interface {\n    public async execute(builder: ModelFactory.Builder) {\n        return [\n            builder\n                .private({\n                    modelId: FILTER_MODEL_ID,\n                    name: \"ACO - Filter\",\n                    lifecycleEvents: false\n                })\n                .fields(fields => ({\n                    name: fields.text().label(\"Name\").required(),\n                    description: fields.text().label(\"Description\"),\n                    namespace: fields.text().label(\"Model Id\").required(),\n                    operation: fields\n                        .text()\n                        .label(\"Operation\")\n                        .required()\n                        .predefinedValues([\n                            {\n                                label: \"AND\",\n                                value: \"AND\"\n                            },\n                            {\n                                label: \"OR\",\n                                value: \"OR\"\n                            }\n                        ]),\n                    groups: fields\n                        .object()\n                        .label(\"Groups\")\n                        .list()\n                        .listMinLength(1, \"At least one group is required.\")\n                        .fields(fields => ({\n                            operation: fields\n                                .text()\n                                .label(\"Operation\")\n                                .required()\n                                .predefinedValues([\n                                    {\n                                        label: \"AND\",\n                                        value: \"AND\"\n                                    },\n                                    {\n                                        label: \"OR\",\n                                        value: \"OR\"\n                                    }\n                                ]),\n                            filters: fields\n                                .object()\n                                .label(\"Filters\")\n                                .list()\n                                .listMinLength(1, \"At least one filter is required.\")\n                                .fields(filterFields => ({\n                                    field: filterFields.text().label(\"Field\").required(),\n                                    condition: filterFields.text().label(\"Condition\").required(),\n                                    value: filterFields.text().label(\"Value\").required()\n                                }))\n                        }))\n                }))\n        ];\n    }\n}\n\nexport const FilterPrivateModel = ModelFactory.createImplementation({\n    implementation: FilterPrivateModelImpl,\n    dependencies: []\n});\n"],"names":["FILTER_MODEL_ID","process","FilterPrivateModelImpl","builder","fields","filterFields","FilterPrivateModel","ModelFactory"],"mappings":";AAEO,MAAMA,kBAAkBC,QAAQ,GAAG,CAAC,wBAAwB,GAAG,cAAc;AAEpF,MAAMC;IACF,MAAa,QAAQC,OAA6B,EAAE;QAChD,OAAO;YACHA,QACK,OAAO,CAAC;gBACL,SAASH;gBACT,MAAM;gBACN,iBAAiB;YACrB,GACC,MAAM,CAACI,CAAAA,SAAW;oBACf,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC,QAAQ,QAAQ;oBAC1C,aAAaA,OAAO,IAAI,GAAG,KAAK,CAAC;oBACjC,WAAWA,OAAO,IAAI,GAAG,KAAK,CAAC,YAAY,QAAQ;oBACnD,WAAWA,OACN,IAAI,GACJ,KAAK,CAAC,aACN,QAAQ,GACR,gBAAgB,CAAC;wBACd;4BACI,OAAO;4BACP,OAAO;wBACX;wBACA;4BACI,OAAO;4BACP,OAAO;wBACX;qBACH;oBACL,QAAQA,OACH,MAAM,GACN,KAAK,CAAC,UACN,IAAI,GACJ,aAAa,CAAC,GAAG,mCACjB,MAAM,CAACA,CAAAA,SAAW;4BACf,WAAWA,OACN,IAAI,GACJ,KAAK,CAAC,aACN,QAAQ,GACR,gBAAgB,CAAC;gCACd;oCACI,OAAO;oCACP,OAAO;gCACX;gCACA;oCACI,OAAO;oCACP,OAAO;gCACX;6BACH;4BACL,SAASA,OACJ,MAAM,GACN,KAAK,CAAC,WACN,IAAI,GACJ,aAAa,CAAC,GAAG,oCACjB,MAAM,CAACC,CAAAA,eAAiB;oCACrB,OAAOA,aAAa,IAAI,GAAG,KAAK,CAAC,SAAS,QAAQ;oCAClD,WAAWA,aAAa,IAAI,GAAG,KAAK,CAAC,aAAa,QAAQ;oCAC1D,OAAOA,aAAa,IAAI,GAAG,KAAK,CAAC,SAAS,QAAQ;gCACtD;wBACR;gBACR;SACP;IACL;AACJ;AAEO,MAAMC,qBAAqBC,aAAa,oBAAoB,CAAC;IAChE,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/filter/filter.so.d.ts

@@ -0,0 +1,9 @@
+import type { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/abstractions.js";
+import type { Container } from "@webiny/di";
+interface CreateFilterOperationsParams {
+    identityContext: IdentityContext.Interface;
+    container: Container;
+}
+import type { AcoFilterStorageOperations } from "./filter.types.js";
+export declare const createFilterOperations: (params: CreateFilterOperationsParams) => AcoFilterStorageOperations;
+export {};

package/filter/filter.so.js

@@ -0,0 +1,96 @@
+import omit from "lodash/omit.js";
+import error from "@webiny/error";
+import { FILTER_MODEL_ID } from "./filter.model.js";
+import { createListSort } from "../utils/createListSort.js";
+import { createOperationsWrapper } from "../utils/createOperationsWrapper.js";
+import { pickEntryFieldValues } from "../utils/pickEntryFieldValues.js";
+import { ENTRY_META_FIELDS } from "@webiny/api-headless-cms/constants.js";
+import { CmsSortMapper, CmsWhereMapper } from "@webiny/api-headless-cms";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+const unwrap = (result)=>{
+    if (result.isFail()) throw result.error;
+    return result.value;
+};
+const createFilterOperations = (params)=>{
+    const { identityContext, container } = params;
+    const { withModel } = createOperationsWrapper({
+        identityContext,
+        container,
+        modelName: FILTER_MODEL_ID
+    });
+    const cmsWhereMapper = container.resolve(CmsWhereMapper);
+    const cmsSortMapper = container.resolve(CmsSortMapper);
+    return {
+        getFilter ({ id }) {
+            return withModel(async (model)=>{
+                const entry = unwrap(await container.resolve(GetEntryByIdUseCase).execute(model, id));
+                if (!entry) throw new error("Could not load filter.", "GET_FILTER_ERROR", {
+                    id
+                });
+                return pickEntryFieldValues(entry);
+            });
+        },
+        listFilters (params) {
+            return withModel(async (model)=>{
+                const { sort, where } = params;
+                const createdBy = identityContext.getIdentity().id;
+                const result = await container.resolve(ListLatestEntriesUseCase).execute(model, {
+                    ...params,
+                    sort: cmsSortMapper.map({
+                        input: createListSort(sort),
+                        fields: model.fields
+                    }),
+                    where: cmsWhereMapper.map({
+                        input: {
+                            ...where,
+                            createdBy
+                        },
+                        fields: model.fields
+                    })
+                });
+                const { entries, meta } = unwrap(result);
+                return [
+                    entries.map(pickEntryFieldValues),
+                    meta
+                ];
+            });
+        },
+        createFilter ({ data }) {
+            return withModel(async (model)=>{
+                const result = await container.resolve(CreateEntryUseCase).execute(model, {
+                    id: data.id,
+                    values: data
+                });
+                const entry = unwrap(result);
+                return pickEntryFieldValues(entry);
+            });
+        },
+        updateFilter ({ id, data }) {
+            return withModel(async (model)=>{
+                const original = unwrap(await container.resolve(GetEntryByIdUseCase).execute(model, id));
+                const input = {
+                    ...omit(original, ENTRY_META_FIELDS),
+                    values: {
+                        ...original.values,
+                        ...data
+                    }
+                };
+                const entry = unwrap(await container.resolve(UpdateEntryUseCase).execute(model, original.id, input));
+                return pickEntryFieldValues(entry);
+            });
+        },
+        deleteFilter ({ id }) {
+            return withModel(async (model)=>{
+                unwrap(await container.resolve(DeleteEntryUseCase).execute(model, id));
+                return true;
+            });
+        }
+    };
+};
+export { createFilterOperations };
+
+//# sourceMappingURL=filter.so.js.map

package/filter/filter.so.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter/filter.so.js","sources":["../../src/filter/filter.so.ts"],"sourcesContent":["import omit from \"lodash/omit.js\";\nimport WebinyError from \"@webiny/error\";\nimport { FILTER_MODEL_ID } from \"./filter.model.js\";\nimport type { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/abstractions.js\";\nimport type { Container } from \"@webiny/di\";\n\ninterface CreateFilterOperationsParams {\n    identityContext: IdentityContext.Interface;\n    container: Container;\n}\nimport { createListSort } from \"~/utils/createListSort.js\";\nimport { createOperationsWrapper } from \"~/utils/createOperationsWrapper.js\";\nimport { pickEntryFieldValues } from \"~/utils/pickEntryFieldValues.js\";\nimport type { AcoFilterStorageOperations, Filter } from \"./filter.types.js\";\nimport { ENTRY_META_FIELDS } from \"@webiny/api-headless-cms/constants.js\";\nimport { CmsSortMapper, CmsWhereMapper } from \"@webiny/api-headless-cms\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries/index.js\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport type { Result } from \"@webiny/feature/api\";\n\nconst unwrap = <TValue>(result: Result<TValue, Error>): TValue => {\n    if (result.isFail()) {\n        throw result.error;\n    }\n    return result.value;\n};\n\nexport const createFilterOperations = (\n    params: CreateFilterOperationsParams\n): AcoFilterStorageOperations => {\n    const { identityContext, container } = params;\n\n    const { withModel } = createOperationsWrapper({\n        identityContext,\n        container,\n        modelName: FILTER_MODEL_ID\n    });\n\n    /*\n     * The CMS use cases are resolved when an operation runs, not here. These operations are built\n     * while ACO's storage is being resolved, and resolving the use cases at this point loops back\n     * into that same storage until the stack overflows.\n     */\n\n    const cmsWhereMapper = container.resolve(CmsWhereMapper);\n    const cmsSortMapper = container.resolve(CmsSortMapper);\n\n    return {\n        getFilter({ id }) {\n            return withModel(async model => {\n                const entry = unwrap(\n                    await container.resolve(GetEntryByIdUseCase).execute(model, id)\n                );\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 = identityContext.getIdentity().id;\n\n                const result = await container.resolve(ListLatestEntriesUseCase).execute(model, {\n                    ...params,\n                    sort: cmsSortMapper.map({\n                        input: createListSort(sort),\n                        fields: model.fields\n                    }),\n                    where: cmsWhereMapper.map({\n                        input: {\n                            ...where,\n                            createdBy\n                        },\n                        fields: model.fields\n                    })\n                });\n                const { entries, meta } = unwrap(result);\n\n                return [entries.map(pickEntryFieldValues<Filter>), meta];\n            });\n        },\n        createFilter({ data }) {\n            return withModel(async model => {\n                const result = await container.resolve(CreateEntryUseCase).execute(model, {\n                    id: data.id,\n                    values: data\n                });\n                const entry = unwrap(result);\n                return pickEntryFieldValues(entry);\n            });\n        },\n        updateFilter({ id, data }) {\n            return withModel(async model => {\n                const original = unwrap(\n                    await container.resolve(GetEntryByIdUseCase).execute(model, id)\n                );\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                    values: {\n                        ...original.values,\n                        ...data\n                    }\n                };\n\n                const entry = unwrap(\n                    await container.resolve(UpdateEntryUseCase).execute(model, original.id, input)\n                );\n                return pickEntryFieldValues(entry);\n            });\n        },\n        deleteFilter({ id }) {\n            return withModel(async model => {\n                unwrap(await container.resolve(DeleteEntryUseCase).execute(model, id));\n                return true;\n            });\n        }\n    };\n};\n"],"names":["unwrap","result","createFilterOperations","params","identityContext","container","withModel","createOperationsWrapper","FILTER_MODEL_ID","cmsWhereMapper","CmsWhereMapper","cmsSortMapper","CmsSortMapper","id","model","entry","GetEntryByIdUseCase","WebinyError","pickEntryFieldValues","sort","where","createdBy","ListLatestEntriesUseCase","createListSort","entries","meta","data","CreateEntryUseCase","original","input","omit","ENTRY_META_FIELDS","UpdateEntryUseCase","DeleteEntryUseCase"],"mappings":";;;;;;;;;;;;;AAuBA,MAAMA,SAAS,CAASC;IACpB,IAAIA,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;IAEtB,OAAOA,OAAO,KAAK;AACvB;AAEO,MAAMC,yBAAyB,CAClCC;IAEA,MAAM,EAAEC,eAAe,EAAEC,SAAS,EAAE,GAAGF;IAEvC,MAAM,EAAEG,SAAS,EAAE,GAAGC,wBAAwB;QAC1CH;QACAC;QACA,WAAWG;IACf;IAQA,MAAMC,iBAAiBJ,UAAU,OAAO,CAACK;IACzC,MAAMC,gBAAgBN,UAAU,OAAO,CAACO;IAExC,OAAO;QACH,WAAU,EAAEC,EAAE,EAAE;YACZ,OAAOP,UAAU,OAAMQ;gBACnB,MAAMC,QAAQf,OACV,MAAMK,UAAU,OAAO,CAACW,qBAAqB,OAAO,CAACF,OAAOD;gBAGhE,IAAI,CAACE,OACD,MAAM,IAAIE,MAAY,0BAA0B,oBAAoB;oBAChEJ;gBACJ;gBAGJ,OAAOK,qBAAqBH;YAChC;QACJ;QACA,aAAYZ,MAAM;YACd,OAAOG,UAAU,OAAMQ;gBACnB,MAAM,EAAEK,IAAI,EAAEC,KAAK,EAAE,GAAGjB;gBACxB,MAAMkB,YAAYjB,gBAAgB,WAAW,GAAG,EAAE;gBAElD,MAAMH,SAAS,MAAMI,UAAU,OAAO,CAACiB,0BAA0B,OAAO,CAACR,OAAO;oBAC5E,GAAGX,MAAM;oBACT,MAAMQ,cAAc,GAAG,CAAC;wBACpB,OAAOY,eAAeJ;wBACtB,QAAQL,MAAM,MAAM;oBACxB;oBACA,OAAOL,eAAe,GAAG,CAAC;wBACtB,OAAO;4BACH,GAAGW,KAAK;4BACRC;wBACJ;wBACA,QAAQP,MAAM,MAAM;oBACxB;gBACJ;gBACA,MAAM,EAAEU,OAAO,EAAEC,IAAI,EAAE,GAAGzB,OAAOC;gBAEjC,OAAO;oBAACuB,QAAQ,GAAG,CAACN;oBAA+BO;iBAAK;YAC5D;QACJ;QACA,cAAa,EAAEC,IAAI,EAAE;YACjB,OAAOpB,UAAU,OAAMQ;gBACnB,MAAMb,SAAS,MAAMI,UAAU,OAAO,CAACsB,oBAAoB,OAAO,CAACb,OAAO;oBACtE,IAAIY,KAAK,EAAE;oBACX,QAAQA;gBACZ;gBACA,MAAMX,QAAQf,OAAOC;gBACrB,OAAOiB,qBAAqBH;YAChC;QACJ;QACA,cAAa,EAAEF,EAAE,EAAEa,IAAI,EAAE;YACrB,OAAOpB,UAAU,OAAMQ;gBACnB,MAAMc,WAAW5B,OACb,MAAMK,UAAU,OAAO,CAACW,qBAAqB,OAAO,CAACF,OAAOD;gBAGhE,MAAMgB,QAAQ;oBAKV,GAAGC,KAAKF,UAAUG,kBAAkB;oBACpC,QAAQ;wBACJ,GAAGH,SAAS,MAAM;wBAClB,GAAGF,IAAI;oBACX;gBACJ;gBAEA,MAAMX,QAAQf,OACV,MAAMK,UAAU,OAAO,CAAC2B,oBAAoB,OAAO,CAAClB,OAAOc,SAAS,EAAE,EAAEC;gBAE5E,OAAOX,qBAAqBH;YAChC;QACJ;QACA,cAAa,EAAEF,EAAE,EAAE;YACf,OAAOP,UAAU,OAAMQ;gBACnBd,OAAO,MAAMK,UAAU,OAAO,CAAC4B,oBAAoB,OAAO,CAACnB,OAAOD;gBAClE,OAAO;YACX;QACJ;IACJ;AACJ"}

package/filter/filter.types.d.ts

@@ -0,0 +1,67 @@
+import type { AcoBaseFields, ListMeta, ListSort } from "../types.js";
+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 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 type StorageOperationsListFiltersParams = ListFiltersParams;
+export interface StorageOperationsCreateFilterParams {
+    data: CreateFilterParams;
+}
+export interface StorageOperationsUpdateFilterParams {
+    id: string;
+    data: UpdateFilterParams;
+}
+export type StorageOperationsDeleteFilterParams = DeleteFilterParams;
+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>;
+}
+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,8 @@
+var filter_types_Operation = /*#__PURE__*/ function(Operation) {
+    Operation["AND"] = "AND";
+    Operation["OR"] = "OR";
+    return Operation;
+}({});
+export { filter_types_Operation as Operation };
+
+//# sourceMappingURL=filter.types.js.map

package/filter/filter.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter/filter.types.js","sources":["../../src/filter/filter.types.ts"],"sourcesContent":["import type { AcoBaseFields, ListMeta, ListSort } from \"~/types.js\";\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 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}\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"],"names":["Operation"],"mappings":"AAEO,IAAKA,yBAASA,WAAAA,GAAAA,SAATA,SAAS;;;WAATA"}

package/flp/flp.crud.d.ts

@@ -0,0 +1,7 @@
+import { type AcoFolderLevelPermissionsCrud, type AcoStorageOperations } from "../types.js";
+import type { Tenant } from "@webiny/api-core/types/tenancy.js";
+export interface CreateFlpCrudMethodsParams {
+    getTenant: () => Tenant;
+    storageOperations: AcoStorageOperations;
+}
+export declare const createFlpCrudMethods: ({ storageOperations, getTenant }: CreateFlpCrudMethodsParams) => AcoFolderLevelPermissionsCrud;

package/flp/flp.crud.js

@@ -0,0 +1,74 @@
+import { WebinyError } from "@webiny/error";
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+const createFlpCrudMethods = ({ storageOperations, getTenant })=>({
+        async create (params) {
+            return await storageOperations.flp.create({
+                data: {
+                    ...params,
+                    tenant: getTenant().id
+                }
+            });
+        },
+        async update (id, data) {
+            const original = await this.get(id);
+            if (!original) throw new WebinyError(`Folder level permission with id "${id}" not found.`, "GET_ITEM_UPDATE_FLP_ERROR", {
+                id,
+                data
+            });
+            return await storageOperations.flp.update({
+                original,
+                data: {
+                    ...data,
+                    tenant: getTenant().id
+                }
+            });
+        },
+        async batchUpdate (items) {
+            const batchItems = (await Promise.all(items.map(async ({ id, data })=>{
+                const original = await this.get(id);
+                if (!original) return null;
+                return {
+                    original,
+                    data: {
+                        ...data,
+                        tenant: getTenant().id
+                    }
+                };
+            }))).filter((item)=>null !== item);
+            if (0 === batchItems.length) return [];
+            return await storageOperations.flp.batchUpdate({
+                items: batchItems
+            });
+        },
+        async delete (id) {
+            const flp = await this.get(id);
+            if (!flp) throw new WebinyError(`Folder level permission with id "${id}" not found.`, "GET_ITEM_DELETE_FLP_ERROR", {
+                id
+            });
+            await storageOperations.flp.delete({
+                flp: {
+                    ...flp,
+                    tenant: getTenant().id
+                }
+            });
+            return true;
+        },
+        async get (id) {
+            const entryId = EntryId.from(id);
+            return await storageOperations.flp.get({
+                id: entryId.id,
+                tenant: getTenant().id
+            });
+        },
+        async list ({ where }) {
+            return await storageOperations.flp.list({
+                where: {
+                    ...where,
+                    tenant: getTenant().id
+                }
+            });
+        }
+    });
+export { createFlpCrudMethods };
+
+//# sourceMappingURL=flp.crud.js.map

package/flp/flp.crud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flp/flp.crud.js","sources":["../../src/flp/flp.crud.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport {\n    type AcoFolderLevelPermissionsCrud,\n    type AcoStorageOperations,\n    type CreateFlpParams,\n    type UpdateFlpParams\n} from \"~/types.js\";\nimport type { Tenant } from \"@webiny/api-core/types/tenancy.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nexport interface CreateFlpCrudMethodsParams {\n    getTenant: () => Tenant;\n    storageOperations: AcoStorageOperations;\n}\n\nexport const createFlpCrudMethods = ({\n    storageOperations,\n    getTenant\n}: CreateFlpCrudMethodsParams): AcoFolderLevelPermissionsCrud => {\n    return {\n        async create(params: CreateFlpParams) {\n            return await storageOperations.flp.create({\n                data: { ...params, tenant: getTenant().id }\n            });\n        },\n        async update(id: string, data: UpdateFlpParams) {\n            const original = await this.get(id);\n            if (!original) {\n                throw new WebinyError(\n                    `Folder level permission with id \"${id}\" not found.`,\n                    \"GET_ITEM_UPDATE_FLP_ERROR\",\n                    {\n                        id,\n                        data\n                    }\n                );\n            }\n\n            return await storageOperations.flp.update({\n                original,\n                data: {\n                    ...data,\n                    tenant: getTenant().id\n                }\n            });\n        },\n        async batchUpdate(items: Array<{ id: string; data: UpdateFlpParams }>) {\n            const batchItems = (\n                await Promise.all(\n                    items.map(async ({ id, data }) => {\n                        const original = await this.get(id);\n                        if (!original) {\n                            return null;\n                        }\n                        return {\n                            original,\n                            data: {\n                                ...data,\n                                tenant: getTenant().id\n                            }\n                        };\n                    })\n                )\n            ).filter((item): item is NonNullable<typeof item> => item !== null);\n\n            if (batchItems.length === 0) {\n                return [];\n            }\n\n            return await storageOperations.flp.batchUpdate({\n                items: batchItems\n            });\n        },\n        async delete(id: string) {\n            const flp = await this.get(id);\n            if (!flp) {\n                throw new WebinyError(\n                    `Folder level permission with id \"${id}\" not found.`,\n                    \"GET_ITEM_DELETE_FLP_ERROR\",\n                    {\n                        id\n                    }\n                );\n            }\n\n            await storageOperations.flp.delete({\n                flp: {\n                    ...flp,\n                    tenant: getTenant().id\n                }\n            });\n\n            return true;\n        },\n        async get(id: string) {\n            const entryId = EntryId.from(id);\n            return await storageOperations.flp.get({\n                id: entryId.id,\n                tenant: getTenant().id\n            });\n        },\n        async list({ where }) {\n            return await storageOperations.flp.list({\n                where: {\n                    ...where,\n                    tenant: getTenant().id\n                }\n            });\n        }\n    };\n};\n"],"names":["createFlpCrudMethods","storageOperations","getTenant","params","id","data","original","WebinyError","items","batchItems","Promise","item","flp","entryId","EntryId","where"],"mappings":";;AAeO,MAAMA,uBAAuB,CAAC,EACjCC,iBAAiB,EACjBC,SAAS,EACgB,GAClB;QACH,MAAM,QAAOC,MAAuB;YAChC,OAAO,MAAMF,kBAAkB,GAAG,CAAC,MAAM,CAAC;gBACtC,MAAM;oBAAE,GAAGE,MAAM;oBAAE,QAAQD,YAAY,EAAE;gBAAC;YAC9C;QACJ;QACA,MAAM,QAAOE,EAAU,EAAEC,IAAqB;YAC1C,MAAMC,WAAW,MAAM,IAAI,CAAC,GAAG,CAACF;YAChC,IAAI,CAACE,UACD,MAAM,IAAIC,YACN,CAAC,iCAAiC,EAAEH,GAAG,YAAY,CAAC,EACpD,6BACA;gBACIA;gBACAC;YACJ;YAIR,OAAO,MAAMJ,kBAAkB,GAAG,CAAC,MAAM,CAAC;gBACtCK;gBACA,MAAM;oBACF,GAAGD,IAAI;oBACP,QAAQH,YAAY,EAAE;gBAC1B;YACJ;QACJ;QACA,MAAM,aAAYM,KAAmD;YACjE,MAAMC,aACF,OAAMC,QAAQ,GAAG,CACbF,MAAM,GAAG,CAAC,OAAO,EAAEJ,EAAE,EAAEC,IAAI,EAAE;gBACzB,MAAMC,WAAW,MAAM,IAAI,CAAC,GAAG,CAACF;gBAChC,IAAI,CAACE,UACD,OAAO;gBAEX,OAAO;oBACHA;oBACA,MAAM;wBACF,GAAGD,IAAI;wBACP,QAAQH,YAAY,EAAE;oBAC1B;gBACJ;YACJ,GAAE,EAER,MAAM,CAAC,CAACS,OAA2CA,AAAS,SAATA;YAErD,IAAIF,AAAsB,MAAtBA,WAAW,MAAM,EACjB,OAAO,EAAE;YAGb,OAAO,MAAMR,kBAAkB,GAAG,CAAC,WAAW,CAAC;gBAC3C,OAAOQ;YACX;QACJ;QACA,MAAM,QAAOL,EAAU;YACnB,MAAMQ,MAAM,MAAM,IAAI,CAAC,GAAG,CAACR;YAC3B,IAAI,CAACQ,KACD,MAAM,IAAIL,YACN,CAAC,iCAAiC,EAAEH,GAAG,YAAY,CAAC,EACpD,6BACA;gBACIA;YACJ;YAIR,MAAMH,kBAAkB,GAAG,CAAC,MAAM,CAAC;gBAC/B,KAAK;oBACD,GAAGW,GAAG;oBACN,QAAQV,YAAY,EAAE;gBAC1B;YACJ;YAEA,OAAO;QACX;QACA,MAAM,KAAIE,EAAU;YAChB,MAAMS,UAAUC,QAAQ,IAAI,CAACV;YAC7B,OAAO,MAAMH,kBAAkB,GAAG,CAAC,GAAG,CAAC;gBACnC,IAAIY,QAAQ,EAAE;gBACd,QAAQX,YAAY,EAAE;YAC1B;QACJ;QACA,MAAM,MAAK,EAAEa,KAAK,EAAE;YAChB,OAAO,MAAMd,kBAAkB,GAAG,CAAC,IAAI,CAAC;gBACpC,OAAO;oBACH,GAAGc,KAAK;oBACR,QAAQb,YAAY,EAAE;gBAC1B;YACJ;QACJ;IACJ"}

package/flp/flp.types.d.ts

@@ -0,0 +1,98 @@
+import { type Folder } from "../types.js";
+import type { FolderLevelPermission, FolderPermission } from "@webiny/shared-aco/flp/flp.types.js";
+export type * from "@webiny/shared-aco/flp/flp.types.js";
+/********
+ * CRUD operations
+ *******/
+export interface ListFlpsParams {
+    where: {
+        path_startsWith?: string;
+        parentId?: string;
+        type: string;
+    };
+}
+export type CreateFlpParams = Pick<FolderLevelPermission, "id" | "type" | "permissions" | "path" | "parentId" | "slug">;
+export interface UpdateFlpParams {
+    parentId?: string;
+    slug?: string;
+    path?: string;
+    permissions?: FolderPermission[];
+    type?: string;
+}
+export interface AcoFolderLevelPermissionsCrud {
+    list(params: ListFlpsParams): Promise<FolderLevelPermission[]>;
+    get(id: string): Promise<FolderLevelPermission | null>;
+    create(params: CreateFlpParams): Promise<FolderLevelPermission>;
+    update(id: string, data: UpdateFlpParams): Promise<FolderLevelPermission>;
+    delete(id: string): Promise<boolean>;
+    batchUpdate(items: Array<{
+        id: string;
+        data: UpdateFlpParams;
+    }>): Promise<FolderLevelPermission[]>;
+}
+/********
+ * Storage operations
+ *******/
+export interface StorageOperationsListFlpsParams {
+    where: ListFlpsParams["where"] & {
+        tenant: string;
+    };
+}
+export interface StorageOperationsGetFlpParams {
+    id: string;
+    tenant: string;
+}
+export type StorageOperationsCreateFlpParams = {
+    data: FolderLevelPermission & {
+        tenant: string;
+    };
+};
+export type StorageOperationsUpdateFlpParams = {
+    original: FolderLevelPermission;
+    data: UpdateFlpParams & {
+        tenant: string;
+    };
+};
+export type StorageOperationsDeleteFlpParams = {
+    flp: FolderLevelPermission & {
+        tenant: string;
+    };
+};
+export interface StorageOperationsBatchUpdateFlpParams {
+    items: Array<{
+        original: FolderLevelPermission;
+        data: UpdateFlpParams & {
+            tenant: string;
+        };
+    }>;
+}
+export interface AcoFolderLevelPermissionsStorageOperations {
+    list(params: StorageOperationsListFlpsParams): Promise<FolderLevelPermission[]>;
+    get(params: StorageOperationsGetFlpParams): Promise<FolderLevelPermission | null>;
+    create(params: StorageOperationsCreateFlpParams): Promise<FolderLevelPermission>;
+    update(params: StorageOperationsUpdateFlpParams): Promise<FolderLevelPermission>;
+    delete(params: StorageOperationsDeleteFlpParams): Promise<void>;
+    batchUpdate(params: StorageOperationsBatchUpdateFlpParams): Promise<FolderLevelPermission[]>;
+}
+/********
+ *  Background Tasks
+ *******/
+export interface ICreateFlpTaskInput {
+    folder: Folder;
+    /** Who created the folder. Their open admin tabs are told once the FLP record exists. */
+    notifyIdentityId?: string;
+}
+export interface IUpdateFlpTaskInput {
+    folder: Folder;
+    /** Folders whose whole subtree an earlier run of this task already wrote. */
+    completed?: string[];
+    /** Who changed the folder. Their open admin tabs are told once the whole subtree is written. */
+    notifyIdentityId?: string;
+}
+export interface IDeleteFlpTaskInput {
+    folder: Folder;
+}
+export interface ISyncFlpTaskInput {
+    type?: string;
+    folderId?: string;
+}