@webiny/api-aco 0.0.0-ee-vpcs.549378cf03 → 0.0.0-unstable.06b2ede40f

package/utils/FoldersCacheFactory.d.ts

@@ -0,0 +1,10 @@
+import type { Folder } from "../folder/folder.types";
+import { ListCache } from "./ListCache";
+export declare class FoldersCacheFactory {
+    private cache;
+    hasCache(namespace: string): boolean;
+    getCache(namespace: string): ListCache<Folder>;
+    deleteCache(): void;
+    private getCacheKey;
+}
+export declare const folderCacheFactory: FoldersCacheFactory;

package/utils/FoldersCacheFactory.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.folderCacheFactory = exports.FoldersCacheFactory = void 0;
+var _ListCache = require("./ListCache");
+class FoldersCacheFactory {
+  cache = new Map();
+  hasCache(namespace) {
+    const cacheKey = this.getCacheKey(namespace);
+    return this.cache.has(cacheKey);
+  }
+  getCache(namespace) {
+    const cacheKey = this.getCacheKey(namespace);
+    if (!this.cache.has(cacheKey)) {
+      this.cache.set(cacheKey, new _ListCache.ListCache());
+    }
+    return this.cache.get(cacheKey);
+  }
+  deleteCache() {
+    this.cache.clear();
+  }
+  getCacheKey(namespace) {
+    return namespace;
+  }
+}
+exports.FoldersCacheFactory = FoldersCacheFactory;
+const folderCacheFactory = exports.folderCacheFactory = new FoldersCacheFactory();
+
+//# sourceMappingURL=FoldersCacheFactory.js.map

package/utils/FoldersCacheFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_ListCache","require","FoldersCacheFactory","cache","Map","hasCache","namespace","cacheKey","getCacheKey","has","getCache","set","ListCache","get","deleteCache","clear","exports","folderCacheFactory"],"sources":["FoldersCacheFactory.ts"],"sourcesContent":["import type { Folder } from \"~/folder/folder.types\";\nimport { ListCache } from \"~/utils/ListCache\";\n\nexport class FoldersCacheFactory {\n    private cache: Map<string, ListCache<Folder>> = new Map();\n\n    hasCache(namespace: string) {\n        const cacheKey = this.getCacheKey(namespace);\n        return this.cache.has(cacheKey);\n    }\n\n    getCache(namespace: string) {\n        const cacheKey = this.getCacheKey(namespace);\n\n        if (!this.cache.has(cacheKey)) {\n            this.cache.set(cacheKey, new ListCache<Folder>());\n        }\n\n        return this.cache.get(cacheKey) as ListCache<Folder>;\n    }\n\n    deleteCache() {\n        this.cache.clear();\n    }\n\n    private getCacheKey(namespace: string) {\n        return namespace;\n    }\n}\n\nexport const folderCacheFactory = new FoldersCacheFactory();\n"],"mappings":";;;;;;AACA,IAAAA,UAAA,GAAAC,OAAA;AAEO,MAAMC,mBAAmB,CAAC;EACrBC,KAAK,GAAmC,IAAIC,GAAG,CAAC,CAAC;EAEzDC,QAAQA,CAACC,SAAiB,EAAE;IACxB,MAAMC,QAAQ,GAAG,IAAI,CAACC,WAAW,CAACF,SAAS,CAAC;IAC5C,OAAO,IAAI,CAACH,KAAK,CAACM,GAAG,CAACF,QAAQ,CAAC;EACnC;EAEAG,QAAQA,CAACJ,SAAiB,EAAE;IACxB,MAAMC,QAAQ,GAAG,IAAI,CAACC,WAAW,CAACF,SAAS,CAAC;IAE5C,IAAI,CAAC,IAAI,CAACH,KAAK,CAACM,GAAG,CAACF,QAAQ,CAAC,EAAE;MAC3B,IAAI,CAACJ,KAAK,CAACQ,GAAG,CAACJ,QAAQ,EAAE,IAAIK,oBAAS,CAAS,CAAC,CAAC;IACrD;IAEA,OAAO,IAAI,CAACT,KAAK,CAACU,GAAG,CAACN,QAAQ,CAAC;EACnC;EAEAO,WAAWA,CAAA,EAAG;IACV,IAAI,CAACX,KAAK,CAACY,KAAK,CAAC,CAAC;EACtB;EAEQP,WAAWA,CAACF,SAAiB,EAAE;IACnC,OAAOA,SAAS;EACpB;AACJ;AAACU,OAAA,CAAAd,mBAAA,GAAAA,mBAAA;AAEM,MAAMe,kBAAkB,GAAAD,OAAA,CAAAC,kBAAA,GAAG,IAAIf,mBAAmB,CAAC,CAAC","ignoreList":[]}

package/utils/ListCache.d.ts

@@ -0,0 +1,23 @@
+export type Constructor<T> = new (...args: any[]) => T;
+export interface IListCachePredicate<T> {
+    (item: T): boolean;
+}
+export interface IListCacheItemUpdater<T> {
+    (item: T): T;
+}
+export interface IListCache<T> {
+    clear(): void;
+    hasItems(): boolean;
+    getItems(): T[];
+    addItems(items: T[]): void;
+    updateItems(updater: IListCacheItemUpdater<T>): void;
+}
+export declare class ListCache<T> implements IListCache<T> {
+    private state;
+    constructor();
+    clear(): void;
+    hasItems(): boolean;
+    getItems(): T[];
+    addItems(items: T[]): void;
+    updateItems(updater: IListCacheItemUpdater<T>): void;
+}

package/utils/ListCache.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListCache = void 0;
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+class ListCache {
+  constructor() {
+    this.state = [];
+  }
+  clear() {
+    this.state = [];
+  }
+  hasItems() {
+    return this.state.length > 0;
+  }
+  getItems() {
+    return (0, _cloneDeep.default)(this.state);
+  }
+  addItems(items) {
+    this.state.push(...items);
+  }
+  updateItems(updater) {
+    this.state = this.state.map(item => updater(item));
+  }
+}
+exports.ListCache = ListCache;
+
+//# sourceMappingURL=ListCache.js.map

package/utils/ListCache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_cloneDeep","_interopRequireDefault","require","ListCache","constructor","state","clear","hasItems","length","getItems","cloneDeep","addItems","items","push","updateItems","updater","map","item","exports"],"sources":["ListCache.ts"],"sourcesContent":["import cloneDeep from \"lodash/cloneDeep\";\n\nexport type Constructor<T> = new (...args: any[]) => T;\n\nexport interface IListCachePredicate<T> {\n    (item: T): boolean;\n}\n\nexport interface IListCacheItemUpdater<T> {\n    (item: T): T;\n}\n\nexport interface IListCache<T> {\n    clear(): void;\n    hasItems(): boolean;\n    getItems(): T[];\n    addItems(items: T[]): void;\n    updateItems(updater: IListCacheItemUpdater<T>): void;\n}\n\nexport class ListCache<T> implements IListCache<T> {\n    private state: T[];\n\n    constructor() {\n        this.state = [];\n    }\n\n    clear(): void {\n        this.state = [];\n    }\n\n    hasItems(): boolean {\n        return this.state.length > 0;\n    }\n\n    getItems(): T[] {\n        return cloneDeep(this.state);\n    }\n\n    addItems(items: T[]): void {\n        this.state.push(...items);\n    }\n\n    updateItems(updater: IListCacheItemUpdater<T>): void {\n        this.state = this.state.map(item => updater(item));\n    }\n}\n"],"mappings":";;;;;;;AAAA,IAAAA,UAAA,GAAAC,sBAAA,CAAAC,OAAA;AAoBO,MAAMC,SAAS,CAA6B;EAG/CC,WAAWA,CAAA,EAAG;IACV,IAAI,CAACC,KAAK,GAAG,EAAE;EACnB;EAEAC,KAAKA,CAAA,EAAS;IACV,IAAI,CAACD,KAAK,GAAG,EAAE;EACnB;EAEAE,QAAQA,CAAA,EAAY;IAChB,OAAO,IAAI,CAACF,KAAK,CAACG,MAAM,GAAG,CAAC;EAChC;EAEAC,QAAQA,CAAA,EAAQ;IACZ,OAAO,IAAAC,kBAAS,EAAC,IAAI,CAACL,KAAK,CAAC;EAChC;EAEAM,QAAQA,CAACC,KAAU,EAAQ;IACvB,IAAI,CAACP,KAAK,CAACQ,IAAI,CAAC,GAAGD,KAAK,CAAC;EAC7B;EAEAE,WAAWA,CAACC,OAAiC,EAAQ;IACjD,IAAI,CAACV,KAAK,GAAG,IAAI,CAACA,KAAK,CAACW,GAAG,CAACC,IAAI,IAAIF,OAAO,CAACE,IAAI,CAAC,CAAC;EACtD;AACJ;AAACC,OAAA,CAAAf,SAAA,GAAAA,SAAA","ignoreList":[]}

package/utils/ListFoldersRepository.d.ts

@@ -0,0 +1,10 @@
+import type { Folder, ListFoldersParams } from "../folder/folder.types";
+import type { ListMeta } from "../types";
+export interface ListFoldersRepositoryParams {
+    gateway: (params: ListFoldersParams) => Promise<[Folder[], ListMeta]>;
+}
+export declare class ListFoldersRepository {
+    private readonly gateway;
+    constructor(params: ListFoldersRepositoryParams);
+    execute(folderType: string): Promise<Folder[]>;
+}

package/utils/ListFoldersRepository.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ListFoldersRepository = void 0;
+var _FoldersCacheFactory = require("./FoldersCacheFactory");
+class ListFoldersRepository {
+  constructor(params) {
+    this.gateway = params.gateway;
+  }
+  async execute(folderType) {
+    if (_FoldersCacheFactory.folderCacheFactory.hasCache(folderType)) {
+      return _FoldersCacheFactory.folderCacheFactory.getCache(folderType).getItems();
+    }
+    let hasMoreItems = true;
+    let cursor = null;
+    while (hasMoreItems) {
+      const response = await this.gateway({
+        where: {
+          type: folderType
+        },
+        after: cursor
+      });
+      const [folders, meta] = response;
+      _FoldersCacheFactory.folderCacheFactory.getCache(folderType).addItems(folders);
+      hasMoreItems = meta.hasMoreItems;
+      cursor = meta.cursor;
+    }
+    return _FoldersCacheFactory.folderCacheFactory.getCache(folderType).getItems();
+  }
+}
+exports.ListFoldersRepository = ListFoldersRepository;
+
+//# sourceMappingURL=ListFoldersRepository.js.map

package/utils/ListFoldersRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_FoldersCacheFactory","require","ListFoldersRepository","constructor","params","gateway","execute","folderType","folderCacheFactory","hasCache","getCache","getItems","hasMoreItems","cursor","response","where","type","after","folders","meta","addItems","exports"],"sources":["ListFoldersRepository.ts"],"sourcesContent":["import { folderCacheFactory } from \"~/utils/FoldersCacheFactory\";\nimport type { Folder, ListFoldersParams } from \"~/folder/folder.types\";\nimport type { ListMeta } from \"~/types\";\n\nexport interface ListFoldersRepositoryParams {\n    gateway: (params: ListFoldersParams) => Promise<[Folder[], ListMeta]>;\n}\n\nexport class ListFoldersRepository {\n    private readonly gateway: (params: ListFoldersParams) => Promise<[Folder[], ListMeta]>;\n\n    constructor(params: ListFoldersRepositoryParams) {\n        this.gateway = params.gateway;\n    }\n\n    public async execute(folderType: string): Promise<Folder[]> {\n        if (folderCacheFactory.hasCache(folderType)) {\n            return folderCacheFactory.getCache(folderType).getItems();\n        }\n\n        let hasMoreItems: ListMeta[\"hasMoreItems\"] = true;\n        let cursor: ListMeta[\"cursor\"] = null;\n\n        while (hasMoreItems) {\n            const response: [Folder[], ListMeta] = await this.gateway({\n                where: { type: folderType },\n                after: cursor\n            });\n\n            const [folders, meta] = response;\n\n            folderCacheFactory.getCache(folderType).addItems(folders);\n            hasMoreItems = meta.hasMoreItems;\n            cursor = meta.cursor;\n        }\n\n        return folderCacheFactory.getCache(folderType).getItems();\n    }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,oBAAA,GAAAC,OAAA;AAQO,MAAMC,qBAAqB,CAAC;EAG/BC,WAAWA,CAACC,MAAmC,EAAE;IAC7C,IAAI,CAACC,OAAO,GAAGD,MAAM,CAACC,OAAO;EACjC;EAEA,MAAaC,OAAOA,CAACC,UAAkB,EAAqB;IACxD,IAAIC,uCAAkB,CAACC,QAAQ,CAACF,UAAU,CAAC,EAAE;MACzC,OAAOC,uCAAkB,CAACE,QAAQ,CAACH,UAAU,CAAC,CAACI,QAAQ,CAAC,CAAC;IAC7D;IAEA,IAAIC,YAAsC,GAAG,IAAI;IACjD,IAAIC,MAA0B,GAAG,IAAI;IAErC,OAAOD,YAAY,EAAE;MACjB,MAAME,QAA8B,GAAG,MAAM,IAAI,CAACT,OAAO,CAAC;QACtDU,KAAK,EAAE;UAAEC,IAAI,EAAET;QAAW,CAAC;QAC3BU,KAAK,EAAEJ;MACX,CAAC,CAAC;MAEF,MAAM,CAACK,OAAO,EAAEC,IAAI,CAAC,GAAGL,QAAQ;MAEhCN,uCAAkB,CAACE,QAAQ,CAACH,UAAU,CAAC,CAACa,QAAQ,CAACF,OAAO,CAAC;MACzDN,YAAY,GAAGO,IAAI,CAACP,YAAY;MAChCC,MAAM,GAAGM,IAAI,CAACN,MAAM;IACxB;IAEA,OAAOL,uCAAkB,CAACE,QAAQ,CAACH,UAAU,CAAC,CAACI,QAAQ,CAAC,CAAC;EAC7D;AACJ;AAACU,OAAA,CAAAnB,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/utils/Path.d.ts

@@ -0,0 +1,3 @@
+export declare class Path {
+    static create(slug: string, parentPath?: string): string;
+}

package/utils/Path.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Path = void 0;
+var _constants = require("../constants");
+class Path {
+  static create(slug, parentPath) {
+    if (parentPath) {
+      return `${parentPath}/${slug}`;
+    }
+    return `${_constants.ROOT_FOLDER}/${slug}`;
+  }
+}
+exports.Path = Path;
+
+//# sourceMappingURL=Path.js.map

package/utils/Path.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_constants","require","Path","create","slug","parentPath","ROOT_FOLDER","exports"],"sources":["Path.ts"],"sourcesContent":["import { ROOT_FOLDER } from \"~/constants\";\n\nexport class Path {\n    static create(slug: string, parentPath?: string) {\n        if (parentPath) {\n            return `${parentPath}/${slug}`;\n        }\n\n        return `${ROOT_FOLDER}/${slug}`;\n    }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAEO,MAAMC,IAAI,CAAC;EACd,OAAOC,MAAMA,CAACC,IAAY,EAAEC,UAAmB,EAAE;IAC7C,IAAIA,UAAU,EAAE;MACZ,OAAO,GAAGA,UAAU,IAAID,IAAI,EAAE;IAClC;IAEA,OAAO,GAAGE,sBAAW,IAAIF,IAAI,EAAE;EACnC;AACJ;AAACG,OAAA,CAAAL,IAAA,GAAAA,IAAA","ignoreList":[]}

package/utils/acoRecordId.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 006
+ * PageDataMigration in ddb-es and ddb
+ */
+export declare const attachAcoRecordPrefix: (id: string) => string;
+export declare const removeAcoRecordPrefix: (id: string) => string;

package/utils/acoRecordId.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeAcoRecordPrefix = exports.attachAcoRecordPrefix = void 0;
+/**
+ * !!! DO NOT CHANGE THIS !!!
+ * If this is changed, you will need to create new migration which changes the IDs for the users.
+ *
+ * packages/migrations/src/migrations/5.35.0/006/ddb/PageDataMigration.ts:236
+ * packages/migrations/src/migrations/5.35.0/006/ddb-es/PageDataMigration.ts:419
+ */
+const WBY_ACO_PREFIX = "wby-aco-";
+/**
+ * 006
+ * PageDataMigration in ddb-es and ddb
+ */
+
+const attachAcoRecordPrefix = id => {
+  if (id.startsWith(WBY_ACO_PREFIX)) {
+    return id;
+  }
+  return `${WBY_ACO_PREFIX}${id}`;
+};
+exports.attachAcoRecordPrefix = attachAcoRecordPrefix;
+const removeAcoRecordPrefix = id => {
+  if (id.startsWith(WBY_ACO_PREFIX) === false) {
+    return id;
+  }
+  return id.substring(WBY_ACO_PREFIX.length);
+};
+exports.removeAcoRecordPrefix = removeAcoRecordPrefix;
+
+//# sourceMappingURL=acoRecordId.js.map

package/utils/acoRecordId.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["WBY_ACO_PREFIX","attachAcoRecordPrefix","id","startsWith","exports","removeAcoRecordPrefix","substring","length"],"sources":["acoRecordId.ts"],"sourcesContent":["/**\n * !!! DO NOT CHANGE THIS !!!\n * If this is changed, you will need to create new migration which changes the IDs for the users.\n *\n * packages/migrations/src/migrations/5.35.0/006/ddb/PageDataMigration.ts:236\n * packages/migrations/src/migrations/5.35.0/006/ddb-es/PageDataMigration.ts:419\n */\nconst WBY_ACO_PREFIX = \"wby-aco-\";\n/**\n * 006\n * PageDataMigration in ddb-es and ddb\n */\n\nexport const attachAcoRecordPrefix = (id: string) => {\n    if (id.startsWith(WBY_ACO_PREFIX)) {\n        return id;\n    }\n    return `${WBY_ACO_PREFIX}${id}`;\n};\n\nexport const removeAcoRecordPrefix = (id: string) => {\n    if (id.startsWith(WBY_ACO_PREFIX) === false) {\n        return id;\n    }\n    return id.substring(WBY_ACO_PREFIX.length);\n};\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,cAAc,GAAG,UAAU;AACjC;AACA;AACA;AACA;;AAEO,MAAMC,qBAAqB,GAAIC,EAAU,IAAK;EACjD,IAAIA,EAAE,CAACC,UAAU,CAACH,cAAc,CAAC,EAAE;IAC/B,OAAOE,EAAE;EACb;EACA,OAAO,GAAGF,cAAc,GAAGE,EAAE,EAAE;AACnC,CAAC;AAACE,OAAA,CAAAH,qBAAA,GAAAA,qBAAA;AAEK,MAAMI,qBAAqB,GAAIH,EAAU,IAAK;EACjD,IAAIA,EAAE,CAACC,UAAU,CAACH,cAAc,CAAC,KAAK,KAAK,EAAE;IACzC,OAAOE,EAAE;EACb;EACA,OAAOA,EAAE,CAACI,SAAS,CAACN,cAAc,CAACO,MAAM,CAAC;AAC9C,CAAC;AAACH,OAAA,CAAAC,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/utils/compress.d.ts

@@ -0,0 +1,4 @@
+export declare const compress: (data: any) => Promise<{
+    compression: string;
+    value: string;
+}>;

package/utils/compress.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compress = void 0;
+var _gzip = require("@webiny/utils/compression/gzip");
+const GZIP = "gzip";
+const TO_STORAGE_ENCODING = "base64";
+const compress = async data => {
+  const value = await (0, _gzip.compress)(JSON.stringify(data));
+  return {
+    compression: GZIP,
+    value: value.toString(TO_STORAGE_ENCODING)
+  };
+};
+exports.compress = compress;
+
+//# sourceMappingURL=compress.js.map

package/utils/compress.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_gzip","require","GZIP","TO_STORAGE_ENCODING","compress","data","value","gzip","JSON","stringify","compression","toString","exports"],"sources":["compress.ts"],"sourcesContent":["import { compress as gzip } from \"@webiny/utils/compression/gzip\";\n\nconst GZIP = \"gzip\";\nconst TO_STORAGE_ENCODING = \"base64\";\n\nexport const compress = async (data: any) => {\n    const value = await gzip(JSON.stringify(data));\n\n    return {\n        compression: GZIP,\n        value: value.toString(TO_STORAGE_ENCODING)\n    };\n};\n"],"mappings":";;;;;;AAAA,IAAAA,KAAA,GAAAC,OAAA;AAEA,MAAMC,IAAI,GAAG,MAAM;AACnB,MAAMC,mBAAmB,GAAG,QAAQ;AAE7B,MAAMC,QAAQ,GAAG,MAAOC,IAAS,IAAK;EACzC,MAAMC,KAAK,GAAG,MAAM,IAAAC,cAAI,EAACC,IAAI,CAACC,SAAS,CAACJ,IAAI,CAAC,CAAC;EAE9C,OAAO;IACHK,WAAW,EAAER,IAAI;IACjBI,KAAK,EAAEA,KAAK,CAACK,QAAQ,CAACR,mBAAmB;EAC7C,CAAC;AACL,CAAC;AAACS,OAAA,CAAAR,QAAA,GAAAA,QAAA","ignoreList":[]}

package/utils/createListSort.d.ts

@@ -0,0 +1,3 @@
+import type { ListSort } from "../types";
+import type { CmsEntryListSort } from "@webiny/api-headless-cms/types";
+export declare const createListSort: (sort?: ListSort) => CmsEntryListSort | undefined;

package/utils/createListSort.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createListSort = void 0;
+const createListSort = sort => {
+  if (!sort) {
+    return;
+  }
+  return Object.keys(sort).map(key => {
+    return `${key}_${sort[key]}`;
+  });
+};
+exports.createListSort = createListSort;
+
+//# sourceMappingURL=createListSort.js.map

package/utils/createListSort.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createListSort","sort","Object","keys","map","key","exports"],"sources":["createListSort.ts"],"sourcesContent":["import type { ListSort } from \"~/types\";\nimport type {\n    CmsEntryListSort,\n    CmsEntryListSortAsc,\n    CmsEntryListSortDesc\n} from \"@webiny/api-headless-cms/types\";\n\nexport const createListSort = (sort?: ListSort): CmsEntryListSort | undefined => {\n    if (!sort) {\n        return;\n    }\n\n    return Object.keys(sort).map(key => {\n        return `${key}_${sort[key]}` as CmsEntryListSortAsc | CmsEntryListSortDesc;\n    });\n};\n"],"mappings":";;;;;;AAOO,MAAMA,cAAc,GAAIC,IAAe,IAAmC;EAC7E,IAAI,CAACA,IAAI,EAAE;IACP;EACJ;EAEA,OAAOC,MAAM,CAACC,IAAI,CAACF,IAAI,CAAC,CAACG,GAAG,CAACC,GAAG,IAAI;IAChC,OAAO,GAAGA,GAAG,IAAIJ,IAAI,CAACI,GAAG,CAAC,EAAE;EAChC,CAAC,CAAC;AACN,CAAC;AAACC,OAAA,CAAAN,cAAA,GAAAA,cAAA","ignoreList":[]}

package/utils/createModelField.d.ts

@@ -0,0 +1,5 @@
+import type { CmsModelField } from "@webiny/api-headless-cms/types";
+export interface CreateModelFieldParams extends Omit<CmsModelField, "id" | "storageId" | "fieldId"> {
+    fieldId?: string;
+}
+export declare const createModelField: (params: CreateModelFieldParams) => CmsModelField;

package/utils/createModelField.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModelField = void 0;
+var _camelCase = _interopRequireDefault(require("lodash/camelCase"));
+const createModelField = params => {
+  const {
+    label,
+    fieldId: initialFieldId,
+    type,
+    settings = {},
+    listValidation = [],
+    validation = [],
+    multipleValues = false,
+    predefinedValues = {
+      values: [],
+      enabled: false
+    }
+  } = params;
+  const fieldId = initialFieldId ? (0, _camelCase.default)(initialFieldId) : (0, _camelCase.default)(label);
+  return {
+    id: fieldId,
+    storageId: `${type}@${fieldId}`,
+    fieldId,
+    label,
+    type,
+    settings,
+    listValidation,
+    validation,
+    multipleValues,
+    predefinedValues
+  };
+};
+exports.createModelField = createModelField;
+
+//# sourceMappingURL=createModelField.js.map

package/utils/createModelField.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_camelCase","_interopRequireDefault","require","createModelField","params","label","fieldId","initialFieldId","type","settings","listValidation","validation","multipleValues","predefinedValues","values","enabled","camelCase","id","storageId","exports"],"sources":["createModelField.ts"],"sourcesContent":["import type { CmsModelField } from \"@webiny/api-headless-cms/types\";\nimport camelCase from \"lodash/camelCase\";\n\nexport interface CreateModelFieldParams\n    extends Omit<CmsModelField, \"id\" | \"storageId\" | \"fieldId\"> {\n    fieldId?: string;\n}\n\nexport const createModelField = (params: CreateModelFieldParams): CmsModelField => {\n    const {\n        label,\n        fieldId: initialFieldId,\n        type,\n        settings = {},\n        listValidation = [],\n        validation = [],\n        multipleValues = false,\n        predefinedValues = {\n            values: [],\n            enabled: false\n        }\n    } = params;\n\n    const fieldId = initialFieldId ? camelCase(initialFieldId) : camelCase(label);\n\n    return {\n        id: fieldId,\n        storageId: `${type}@${fieldId}`,\n        fieldId,\n        label,\n        type,\n        settings,\n        listValidation,\n        validation,\n        multipleValues,\n        predefinedValues\n    };\n};\n"],"mappings":";;;;;;;AACA,IAAAA,UAAA,GAAAC,sBAAA,CAAAC,OAAA;AAOO,MAAMC,gBAAgB,GAAIC,MAA8B,IAAoB;EAC/E,MAAM;IACFC,KAAK;IACLC,OAAO,EAAEC,cAAc;IACvBC,IAAI;IACJC,QAAQ,GAAG,CAAC,CAAC;IACbC,cAAc,GAAG,EAAE;IACnBC,UAAU,GAAG,EAAE;IACfC,cAAc,GAAG,KAAK;IACtBC,gBAAgB,GAAG;MACfC,MAAM,EAAE,EAAE;MACVC,OAAO,EAAE;IACb;EACJ,CAAC,GAAGX,MAAM;EAEV,MAAME,OAAO,GAAGC,cAAc,GAAG,IAAAS,kBAAS,EAACT,cAAc,CAAC,GAAG,IAAAS,kBAAS,EAACX,KAAK,CAAC;EAE7E,OAAO;IACHY,EAAE,EAAEX,OAAO;IACXY,SAAS,EAAE,GAAGV,IAAI,IAAIF,OAAO,EAAE;IAC/BA,OAAO;IACPD,KAAK;IACLG,IAAI;IACJC,QAAQ;IACRC,cAAc;IACdC,UAAU;IACVC,cAAc;IACdC;EACJ,CAAC;AACL,CAAC;AAACM,OAAA,CAAAhB,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/utils/createOperationsWrapper.d.ts

@@ -0,0 +1,9 @@
+import type { CreateAcoStorageOperationsParams } from "../createAcoStorageOperations";
+import type { CmsModel } from "@webiny/api-headless-cms/types";
+interface CreateOperationsWrapperParams extends CreateAcoStorageOperationsParams {
+    modelName: string;
+}
+export declare const createOperationsWrapper: (params: CreateOperationsWrapperParams) => {
+    withModel: <TResult>(cb: (model: CmsModel) => Promise<TResult>) => Promise<TResult>;
+};
+export {};

package/utils/createOperationsWrapper.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOperationsWrapper = void 0;
+var _error = _interopRequireDefault(require("@webiny/error"));
+const createOperationsWrapper = params => {
+  const {
+    cms,
+    modelName
+  } = params;
+  const withModel = async cb => {
+    const model = await cms.getModel(modelName);
+    if (!model) {
+      throw new _error.default(`Could not find "${modelName}" model.`, "MODEL_NOT_FOUND_ERROR");
+    }
+    return cb(model);
+  };
+  return {
+    withModel
+  };
+};
+exports.createOperationsWrapper = createOperationsWrapper;
+
+//# sourceMappingURL=createOperationsWrapper.js.map

package/utils/createOperationsWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_error","_interopRequireDefault","require","createOperationsWrapper","params","cms","modelName","withModel","cb","model","getModel","WebinyError","exports"],"sources":["createOperationsWrapper.ts"],"sourcesContent":["import type { CreateAcoStorageOperationsParams } from \"~/createAcoStorageOperations\";\nimport type { CmsModel } from \"@webiny/api-headless-cms/types\";\nimport WebinyError from \"@webiny/error\";\n\ninterface CreateOperationsWrapperParams extends CreateAcoStorageOperationsParams {\n    modelName: string;\n}\n\nexport const createOperationsWrapper = (params: CreateOperationsWrapperParams) => {\n    const { cms, modelName } = params;\n\n    const withModel = async <TResult>(\n        cb: (model: CmsModel) => Promise<TResult>\n    ): Promise<TResult> => {\n        const model = await cms.getModel(modelName);\n\n        if (!model) {\n            throw new WebinyError(`Could not find \"${modelName}\" model.`, \"MODEL_NOT_FOUND_ERROR\");\n        }\n\n        return cb(model);\n    };\n\n    return { withModel };\n};\n"],"mappings":";;;;;;;AAEA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AAMO,MAAMC,uBAAuB,GAAIC,MAAqC,IAAK;EAC9E,MAAM;IAAEC,GAAG;IAAEC;EAAU,CAAC,GAAGF,MAAM;EAEjC,MAAMG,SAAS,GAAG,MACdC,EAAyC,IACtB;IACnB,MAAMC,KAAK,GAAG,MAAMJ,GAAG,CAACK,QAAQ,CAACJ,SAAS,CAAC;IAE3C,IAAI,CAACG,KAAK,EAAE;MACR,MAAM,IAAIE,cAAW,CAAC,mBAAmBL,SAAS,UAAU,EAAE,uBAAuB,CAAC;IAC1F;IAEA,OAAOE,EAAE,CAACC,KAAK,CAAC;EACpB,CAAC;EAED,OAAO;IAAEF;EAAU,CAAC;AACxB,CAAC;AAACK,OAAA,CAAAT,uBAAA,GAAAA,uBAAA","ignoreList":[]}

package/utils/decorators/CmsEntriesCrudDecorators.d.ts

@@ -0,0 +1,11 @@
+import type { AcoContext } from "../../types";
+type Context = Pick<AcoContext, "aco" | "cms">;
+interface EntryManagerCrudDecoratorsParams {
+    context: Context;
+}
+export declare class CmsEntriesCrudDecorators {
+    private readonly context;
+    constructor({ context }: EntryManagerCrudDecoratorsParams);
+    decorate(): void;
+}
+export {};

package/utils/decorators/CmsEntriesCrudDecorators.js

@@ -0,0 +1,210 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsEntriesCrudDecorators = void 0;
+var _constants = require("../../constants");
+var _ListEntriesFactory = require("./ListEntriesFactory");
+var _FilterEntriesByFolderFactory = require("./FilterEntriesByFolderFactory");
+var _decorateIfModelAuthorizationEnabled = require("./decorateIfModelAuthorizationEnabled");
+class CmsEntriesCrudDecorators {
+  constructor({
+    context
+  }) {
+    this.context = context;
+  }
+  decorate() {
+    const context = this.context;
+    const folderLevelPermissions = context.aco.folderLevelPermissions;
+    const filterEntriesByFolder = new _FilterEntriesByFolderFactory.FilterEntriesByFolderFactory(folderLevelPermissions);
+    const listEntriesHandler = new _ListEntriesFactory.ListEntriesFactory(folderLevelPermissions);
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "listEntries", async (...allParams) => {
+      const [decoratee, model, initialParams] = allParams;
+      return await listEntriesHandler.execute({
+        decoratee,
+        model,
+        initialParams
+      });
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "listLatestEntries", async (...allParams) => {
+      const [decoratee, model, initialParams] = allParams;
+      return await listEntriesHandler.execute({
+        decoratee,
+        model,
+        initialParams
+      });
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "listPublishedEntries", async (...allParams) => {
+      const [decoratee, model, initialParams] = allParams;
+      return await listEntriesHandler.execute({
+        decoratee,
+        model,
+        initialParams
+      });
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "listDeletedEntries", async (...allParams) => {
+      const [decoratee, model, initialParams] = allParams;
+      return await listEntriesHandler.execute({
+        decoratee,
+        model,
+        initialParams
+      });
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "getEntry", async (...allParams) => {
+      const [decoratee, model, params] = allParams;
+      const entry = await decoratee(model, params);
+      const folderId = entry?.location?.folderId;
+      if (!folderId || folderId === _constants.ROOT_FOLDER) {
+        return entry;
+      }
+      const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+      await folderLevelPermissions.ensureCanAccessFolderContent({
+        permissions,
+        rwd: "r"
+      });
+      return entry;
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "getEntryById", async (...allParams) => {
+      const [decoratee, model, params] = allParams;
+      const entry = await decoratee(model, params);
+      const folderId = entry?.location?.folderId;
+      if (!folderId || folderId === _constants.ROOT_FOLDER) {
+        return entry;
+      }
+      const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+      await folderLevelPermissions.ensureCanAccessFolderContent({
+        permissions,
+        rwd: "r"
+      });
+      return entry;
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "getLatestEntriesByIds", async (...allParams) => {
+      const [decoratee, model, ids] = allParams;
+      const entries = await decoratee(model, ids);
+      return filterEntriesByFolder.execute(entries);
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "getPublishedEntriesByIds", async (...allParams) => {
+      const [decoratee, model, ids] = allParams;
+      const entries = await decoratee(model, ids);
+      return filterEntriesByFolder.execute(entries);
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "createEntry", async (...allParams) => {
+      const [decoratee, model, params, options] = allParams;
+      const folderId = params.wbyAco_location?.folderId || params.location?.folderId;
+      if (!folderId || folderId === _constants.ROOT_FOLDER) {
+        return decoratee(model, params, options);
+      }
+      const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+      await folderLevelPermissions.ensureCanAccessFolderContent({
+        permissions,
+        rwd: "w"
+      });
+      return decoratee(model, params, options);
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "createEntryRevisionFrom", async (...allParams) => {
+      const [decoratee, model, id, input, options] = allParams;
+      const entry = await context.cms.storageOperations.entries.getRevisionById(model, {
+        id
+      });
+      const folderId = entry?.location?.folderId;
+      if (!folderId || folderId === _constants.ROOT_FOLDER) {
+        return decoratee(model, id, input, options);
+      }
+      const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+      await folderLevelPermissions.ensureCanAccessFolderContent({
+        permissions,
+        rwd: "w"
+      });
+      return decoratee(model, id, input, options);
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "updateEntry", async (...allParams) => {
+      const [decoratee, model, id, input, meta, options] = allParams;
+      const entry = await context.cms.storageOperations.entries.getRevisionById(model, {
+        id
+      });
+      const folderId = entry?.location?.folderId;
+      if (!folderId || folderId === _constants.ROOT_FOLDER) {
+        return decoratee(model, id, input, meta, options);
+      }
+      const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+      await folderLevelPermissions.ensureCanAccessFolderContent({
+        permissions,
+        rwd: "w"
+      });
+      return decoratee(model, id, input, meta, options);
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "deleteEntry", async (...allParams) => {
+      const [decoratee, model, id, options] = allParams;
+      const entry = await context.cms.storageOperations.entries.getLatestRevisionByEntryId(model, {
+        id
+      });
+      const folderId = entry?.location?.folderId;
+      if (!folderId || folderId === _constants.ROOT_FOLDER) {
+        return decoratee(model, id, options);
+      }
+      const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+      await folderLevelPermissions.ensureCanAccessFolderContent({
+        permissions,
+        rwd: "d"
+      });
+      return decoratee(model, id, options);
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "deleteEntryRevision", async (...allParams) => {
+      const [decoratee, model, id] = allParams;
+      const entry = await context.cms.storageOperations.entries.getRevisionById(model, {
+        id
+      });
+      const folderId = entry?.location?.folderId;
+      if (!folderId || folderId === _constants.ROOT_FOLDER) {
+        return decoratee(model, id);
+      }
+      const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+      await folderLevelPermissions.ensureCanAccessFolderContent({
+        permissions,
+        rwd: "d"
+      });
+      return decoratee(model, id);
+    });
+    (0, _decorateIfModelAuthorizationEnabled.decorateIfModelAuthorizationEnabled)(context.cms, "moveEntry", async (...allParams) => {
+      const [decoratee, model, id, targetFolderId] = allParams;
+
+      /**
+       * First we need to check if user has access to the entries existing folder.
+       */
+      const entry = await context.cms.storageOperations.entries.getRevisionById(model, {
+        id
+      });
+      const folderId = entry?.location?.folderId || _constants.ROOT_FOLDER;
+      /**
+       * If the entry is in the same folder we are trying to move it to, just continue.
+       */
+      if (folderId === targetFolderId) {
+        return decoratee(model, id, targetFolderId);
+      } else if (folderId !== _constants.ROOT_FOLDER) {
+        /**
+         * If entry current folder is not a root, check for access
+         */
+        const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+        await folderLevelPermissions.ensureCanAccessFolderContent({
+          permissions,
+          rwd: "w"
+        });
+      }
+      /**
+       * If target folder is not a ROOT_FOLDER, check for access.
+       */
+      if (targetFolderId !== _constants.ROOT_FOLDER) {
+        const permissions = await folderLevelPermissions.getFolderLevelPermissions(folderId);
+        await folderLevelPermissions.ensureCanAccessFolderContent({
+          permissions,
+          rwd: "w"
+        });
+      }
+      return decoratee(model, id, targetFolderId);
+    });
+  }
+}
+exports.CmsEntriesCrudDecorators = CmsEntriesCrudDecorators;
+
+//# sourceMappingURL=CmsEntriesCrudDecorators.js.map