@webiny/wcp 0.0.0-unstable.df6d94b531 → 0.0.0-unstable.e53eceafb5

package/License.d.ts

@@ -0,0 +1,19 @@
+import type { DecryptedWcpProjectLicense, ILicense, WcpProject } from "./types";
+import { NullLicense } from "./NullLicense";
+import type { WCP_FEATURE_LABEL } from "./index";
+export declare class License implements ILicense {
+    private readonly license;
+    static fromLicenseDto(license: DecryptedWcpProjectLicense | null): NullLicense | License;
+    static fromEnvironment(): Promise<NullLicense | License>;
+    private constructor();
+    getRawLicense(): DecryptedWcpProjectLicense;
+    getProject(): WcpProject | null;
+    canUseFeature(wcpFeatureId: keyof typeof WCP_FEATURE_LABEL): boolean;
+    canUseAacl(): boolean;
+    canUseTeams(): boolean;
+    canUseFolderLevelPermissions(): boolean;
+    canUsePrivateFiles(): boolean;
+    canUseAuditLogs(): boolean;
+    canUseRecordLocking(): boolean;
+    canUseFileManagerThreatDetection(): boolean;
+}

package/License.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.License = void 0;
+var _getWcpProjectEnvironment = require("./getWcpProjectEnvironment");
+var _licenses = require("./licenses");
+var _NullLicense = require("./NullLicense");
+class License {
+  static fromLicenseDto(license) {
+    if (!license) {
+      return new _NullLicense.NullLicense();
+    }
+    return new License(license);
+  }
+  static async fromEnvironment() {
+    const wcpProjectEnvironment = (0, _getWcpProjectEnvironment.getWcpProjectEnvironment)();
+    if (!wcpProjectEnvironment) {
+      return new _NullLicense.NullLicense();
+    }
+    const license = await (0, _licenses.getWcpProjectLicense)({
+      orgId: wcpProjectEnvironment.org.id,
+      projectId: wcpProjectEnvironment.project.id,
+      projectEnvironmentApiKey: wcpProjectEnvironment.apiKey
+    });
+    return License.fromLicenseDto(license);
+  }
+  constructor(license) {
+    this.license = license;
+  }
+  getRawLicense() {
+    return this.license;
+  }
+  getProject() {
+    return {
+      orgId: this.license.orgId,
+      projectId: this.license.projectId
+    };
+  }
+  canUseFeature(wcpFeatureId) {
+    return this.license.package?.features?.[wcpFeatureId]?.enabled === true;
+  }
+  canUseAacl() {
+    return this.canUseFeature("advancedAccessControlLayer");
+  }
+  canUseTeams() {
+    if (!this.canUseAacl()) {
+      return false;
+    }
+    return this.license.package.features.advancedAccessControlLayer.options.teams;
+  }
+  canUseFolderLevelPermissions() {
+    if (!this.canUseAacl()) {
+      return false;
+    }
+    return this.license.package.features.advancedAccessControlLayer.options.folderLevelPermissions;
+  }
+  canUsePrivateFiles() {
+    if (!this.canUseAacl()) {
+      return false;
+    }
+    return this.license.package.features.advancedAccessControlLayer.options.privateFiles;
+  }
+  canUseAuditLogs() {
+    return this.canUseFeature("auditLogs");
+  }
+  canUseRecordLocking() {
+    return this.canUseFeature("recordLocking");
+  }
+  canUseFileManagerThreatDetection() {
+    return this.license.package.features.fileManager?.options.threatDetection ?? false;
+  }
+}
+exports.License = License;
+
+//# sourceMappingURL=License.js.map

package/License.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_getWcpProjectEnvironment","require","_licenses","_NullLicense","License","fromLicenseDto","license","NullLicense","fromEnvironment","wcpProjectEnvironment","getWcpProjectEnvironment","getWcpProjectLicense","orgId","org","id","projectId","project","projectEnvironmentApiKey","apiKey","constructor","getRawLicense","getProject","canUseFeature","wcpFeatureId","package","features","enabled","canUseAacl","canUseTeams","advancedAccessControlLayer","options","teams","canUseFolderLevelPermissions","folderLevelPermissions","canUsePrivateFiles","privateFiles","canUseAuditLogs","canUseRecordLocking","canUseFileManagerThreatDetection","fileManager","threatDetection","exports"],"sources":["License.ts"],"sourcesContent":["import { getWcpProjectEnvironment } from \"~/getWcpProjectEnvironment\";\nimport type { DecryptedWcpProjectLicense, ILicense, WcpProject } from \"~/types\";\nimport { getWcpProjectLicense } from \"~/licenses\";\nimport { NullLicense } from \"~/NullLicense\";\nimport type { WCP_FEATURE_LABEL } from \"~/index\";\n\nexport class License implements ILicense {\n    private readonly license: DecryptedWcpProjectLicense;\n\n    static fromLicenseDto(license: DecryptedWcpProjectLicense | null) {\n        if (!license) {\n            return new NullLicense();\n        }\n\n        return new License(license);\n    }\n\n    static async fromEnvironment() {\n        const wcpProjectEnvironment = getWcpProjectEnvironment();\n\n        if (!wcpProjectEnvironment) {\n            return new NullLicense();\n        }\n\n        const license = await getWcpProjectLicense({\n            orgId: wcpProjectEnvironment.org.id,\n            projectId: wcpProjectEnvironment.project.id,\n            projectEnvironmentApiKey: wcpProjectEnvironment.apiKey\n        });\n\n        return License.fromLicenseDto(license);\n    }\n\n    private constructor(license: DecryptedWcpProjectLicense) {\n        this.license = license;\n    }\n\n    getRawLicense(): DecryptedWcpProjectLicense {\n        return this.license;\n    }\n\n    getProject(): WcpProject | null {\n        return {\n            orgId: this.license.orgId,\n            projectId: this.license.projectId\n        };\n    }\n\n    canUseFeature(wcpFeatureId: keyof typeof WCP_FEATURE_LABEL) {\n        return this.license.package?.features?.[wcpFeatureId]?.enabled === true;\n    }\n\n    canUseAacl() {\n        return this.canUseFeature(\"advancedAccessControlLayer\");\n    }\n\n    canUseTeams() {\n        if (!this.canUseAacl()) {\n            return false;\n        }\n\n        return this.license.package.features.advancedAccessControlLayer.options.teams;\n    }\n\n    canUseFolderLevelPermissions() {\n        if (!this.canUseAacl()) {\n            return false;\n        }\n\n        return this.license.package.features.advancedAccessControlLayer.options\n            .folderLevelPermissions;\n    }\n\n    canUsePrivateFiles() {\n        if (!this.canUseAacl()) {\n            return false;\n        }\n\n        return this.license.package.features.advancedAccessControlLayer.options.privateFiles;\n    }\n\n    canUseAuditLogs() {\n        return this.canUseFeature(\"auditLogs\");\n    }\n\n    canUseRecordLocking() {\n        return this.canUseFeature(\"recordLocking\");\n    }\n\n    canUseFileManagerThreatDetection() {\n        return this.license.package.features.fileManager?.options.threatDetection ?? false;\n    }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,yBAAA,GAAAC,OAAA;AAEA,IAAAC,SAAA,GAAAD,OAAA;AACA,IAAAE,YAAA,GAAAF,OAAA;AAGO,MAAMG,OAAO,CAAqB;EAGrC,OAAOC,cAAcA,CAACC,OAA0C,EAAE;IAC9D,IAAI,CAACA,OAAO,EAAE;MACV,OAAO,IAAIC,wBAAW,CAAC,CAAC;IAC5B;IAEA,OAAO,IAAIH,OAAO,CAACE,OAAO,CAAC;EAC/B;EAEA,aAAaE,eAAeA,CAAA,EAAG;IAC3B,MAAMC,qBAAqB,GAAG,IAAAC,kDAAwB,EAAC,CAAC;IAExD,IAAI,CAACD,qBAAqB,EAAE;MACxB,OAAO,IAAIF,wBAAW,CAAC,CAAC;IAC5B;IAEA,MAAMD,OAAO,GAAG,MAAM,IAAAK,8BAAoB,EAAC;MACvCC,KAAK,EAAEH,qBAAqB,CAACI,GAAG,CAACC,EAAE;MACnCC,SAAS,EAAEN,qBAAqB,CAACO,OAAO,CAACF,EAAE;MAC3CG,wBAAwB,EAAER,qBAAqB,CAACS;IACpD,CAAC,CAAC;IAEF,OAAOd,OAAO,CAACC,cAAc,CAACC,OAAO,CAAC;EAC1C;EAEQa,WAAWA,CAACb,OAAmC,EAAE;IACrD,IAAI,CAACA,OAAO,GAAGA,OAAO;EAC1B;EAEAc,aAAaA,CAAA,EAA+B;IACxC,OAAO,IAAI,CAACd,OAAO;EACvB;EAEAe,UAAUA,CAAA,EAAsB;IAC5B,OAAO;MACHT,KAAK,EAAE,IAAI,CAACN,OAAO,CAACM,KAAK;MACzBG,SAAS,EAAE,IAAI,CAACT,OAAO,CAACS;IAC5B,CAAC;EACL;EAEAO,aAAaA,CAACC,YAA4C,EAAE;IACxD,OAAO,IAAI,CAACjB,OAAO,CAACkB,OAAO,EAAEC,QAAQ,GAAGF,YAAY,CAAC,EAAEG,OAAO,KAAK,IAAI;EAC3E;EAEAC,UAAUA,CAAA,EAAG;IACT,OAAO,IAAI,CAACL,aAAa,CAAC,4BAA4B,CAAC;EAC3D;EAEAM,WAAWA,CAAA,EAAG;IACV,IAAI,CAAC,IAAI,CAACD,UAAU,CAAC,CAAC,EAAE;MACpB,OAAO,KAAK;IAChB;IAEA,OAAO,IAAI,CAACrB,OAAO,CAACkB,OAAO,CAACC,QAAQ,CAACI,0BAA0B,CAACC,OAAO,CAACC,KAAK;EACjF;EAEAC,4BAA4BA,CAAA,EAAG;IAC3B,IAAI,CAAC,IAAI,CAACL,UAAU,CAAC,CAAC,EAAE;MACpB,OAAO,KAAK;IAChB;IAEA,OAAO,IAAI,CAACrB,OAAO,CAACkB,OAAO,CAACC,QAAQ,CAACI,0BAA0B,CAACC,OAAO,CAClEG,sBAAsB;EAC/B;EAEAC,kBAAkBA,CAAA,EAAG;IACjB,IAAI,CAAC,IAAI,CAACP,UAAU,CAAC,CAAC,EAAE;MACpB,OAAO,KAAK;IAChB;IAEA,OAAO,IAAI,CAACrB,OAAO,CAACkB,OAAO,CAACC,QAAQ,CAACI,0BAA0B,CAACC,OAAO,CAACK,YAAY;EACxF;EAEAC,eAAeA,CAAA,EAAG;IACd,OAAO,IAAI,CAACd,aAAa,CAAC,WAAW,CAAC;EAC1C;EAEAe,mBAAmBA,CAAA,EAAG;IAClB,OAAO,IAAI,CAACf,aAAa,CAAC,eAAe,CAAC;EAC9C;EAEAgB,gCAAgCA,CAAA,EAAG;IAC/B,OAAO,IAAI,CAAChC,OAAO,CAACkB,OAAO,CAACC,QAAQ,CAACc,WAAW,EAAET,OAAO,CAACU,eAAe,IAAI,KAAK;EACtF;AACJ;AAACC,OAAA,CAAArC,OAAA,GAAAA,OAAA","ignoreList":[]}

package/NullLicense.d.ts

@@ -0,0 +1,14 @@
+import type { WCP_FEATURE_LABEL } from "./index";
+import type { ILicense, WcpProject } from "./types";
+export declare class NullLicense implements ILicense {
+    getRawLicense(): null;
+    getProject(): WcpProject | null;
+    canUseAacl(): boolean;
+    canUseAuditLogs(): boolean;
+    canUseFeature(featureId: keyof typeof WCP_FEATURE_LABEL): boolean;
+    canUseFileManagerThreatDetection(): boolean;
+    canUseFolderLevelPermissions(): boolean;
+    canUsePrivateFiles(): boolean;
+    canUseRecordLocking(): boolean;
+    canUseTeams(): boolean;
+}

package/NullLicense.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NullLicense = void 0;
+class NullLicense {
+  getRawLicense() {
+    return null;
+  }
+  getProject() {
+    return null;
+  }
+  canUseAacl() {
+    return false;
+  }
+  canUseAuditLogs() {
+    return false;
+  }
+  canUseFeature(featureId) {
+    // For backwards compatibility, we need to check the legacy ENV variable `WEBINY_MULTI_TENANCY`.
+    if (featureId === "multiTenancy") {
+      return process.env.WEBINY_MULTI_TENANCY === "true";
+    }
+    return false;
+  }
+  canUseFileManagerThreatDetection() {
+    return false;
+  }
+  canUseFolderLevelPermissions() {
+    return false;
+  }
+  canUsePrivateFiles() {
+    return false;
+  }
+  canUseRecordLocking() {
+    return false;
+  }
+  canUseTeams() {
+    return false;
+  }
+}
+exports.NullLicense = NullLicense;
+
+//# sourceMappingURL=NullLicense.js.map

package/NullLicense.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NullLicense","getRawLicense","getProject","canUseAacl","canUseAuditLogs","canUseFeature","featureId","process","env","WEBINY_MULTI_TENANCY","canUseFileManagerThreatDetection","canUseFolderLevelPermissions","canUsePrivateFiles","canUseRecordLocking","canUseTeams","exports"],"sources":["NullLicense.ts"],"sourcesContent":["import type { WCP_FEATURE_LABEL } from \"~/index\";\nimport type { ILicense, WcpProject } from \"~/types\";\n\nexport class NullLicense implements ILicense {\n    getRawLicense() {\n        return null;\n    }\n\n    getProject(): WcpProject | null {\n        return null;\n    }\n\n    canUseAacl() {\n        return false;\n    }\n\n    canUseAuditLogs() {\n        return false;\n    }\n\n    canUseFeature(featureId: keyof typeof WCP_FEATURE_LABEL): boolean {\n        // For backwards compatibility, we need to check the legacy ENV variable `WEBINY_MULTI_TENANCY`.\n        if (featureId === \"multiTenancy\") {\n            return process.env.WEBINY_MULTI_TENANCY === \"true\";\n        }\n\n        return false;\n    }\n\n    canUseFileManagerThreatDetection() {\n        return false;\n    }\n\n    canUseFolderLevelPermissions() {\n        return false;\n    }\n\n    canUsePrivateFiles() {\n        return false;\n    }\n\n    canUseRecordLocking() {\n        return false;\n    }\n\n    canUseTeams() {\n        return false;\n    }\n}\n"],"mappings":";;;;;;AAGO,MAAMA,WAAW,CAAqB;EACzCC,aAAaA,CAAA,EAAG;IACZ,OAAO,IAAI;EACf;EAEAC,UAAUA,CAAA,EAAsB;IAC5B,OAAO,IAAI;EACf;EAEAC,UAAUA,CAAA,EAAG;IACT,OAAO,KAAK;EAChB;EAEAC,eAAeA,CAAA,EAAG;IACd,OAAO,KAAK;EAChB;EAEAC,aAAaA,CAACC,SAAyC,EAAW;IAC9D;IACA,IAAIA,SAAS,KAAK,cAAc,EAAE;MAC9B,OAAOC,OAAO,CAACC,GAAG,CAACC,oBAAoB,KAAK,MAAM;IACtD;IAEA,OAAO,KAAK;EAChB;EAEAC,gCAAgCA,CAAA,EAAG;IAC/B,OAAO,KAAK;EAChB;EAEAC,4BAA4BA,CAAA,EAAG;IAC3B,OAAO,KAAK;EAChB;EAEAC,kBAAkBA,CAAA,EAAG;IACjB,OAAO,KAAK;EAChB;EAEAC,mBAAmBA,CAAA,EAAG;IAClB,OAAO,KAAK;EAChB;EAEAC,WAAWA,CAAA,EAAG;IACV,OAAO,KAAK;EAChB;AACJ;AAACC,OAAA,CAAAf,WAAA,GAAAA,WAAA","ignoreList":[]}

package/encryption.js

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.encrypt = exports.decrypt = void 0;
-
 /**
  * For now, we're not doing actual encryption, just simple base64 encoding/decoding.
  * Potentially, we'll revisit this in the future and implement actual encryption.
  */
+
 const encrypt = rawObject => {
   try {
     return Buffer.from(JSON.stringify(rawObject), "utf-8").toString("base64");
@@ -16,9 +16,7 @@ const encrypt = rawObject => {
     throw new Error("Could not encrypt given data.");
   }
 };
-
 exports.encrypt = encrypt;
-
 const decrypt = encryptedString => {
   try {
     const decryptedString = Buffer.from(encryptedString, "base64").toString("utf-8");
@@ -27,5 +25,6 @@ const decrypt = encryptedString => {
     throw new Error(`Could not decrypt the given string (${encryptedString}).`);
   }
 };
+exports.decrypt = decrypt;
 
-exports.decrypt = decrypt;
+//# sourceMappingURL=encryption.js.map

package/encryption.js.map

@@ -1 +1 @@
-{"version":3,"names":["encrypt","rawObject","Buffer","from","JSON","stringify","toString","Error","decrypt","encryptedString","decryptedString","parse"],"sources":["encryption.ts"],"sourcesContent":["/**\n * For now, we're not doing actual encryption, just simple base64 encoding/decoding.\n * Potentially, we'll revisit this in the future and implement actual encryption.\n */\n\nexport const encrypt = <T = Record<string, any>>(rawObject: T): string => {\n    try {\n        return Buffer.from(JSON.stringify(rawObject), \"utf-8\").toString(\"base64\");\n    } catch {\n        throw new Error(\"Could not encrypt given data.\");\n    }\n};\n\nexport const decrypt = <T = Record<string, any>>(encryptedString: string): T => {\n    try {\n        const decryptedString = Buffer.from(encryptedString, \"base64\").toString(\"utf-8\");\n        return JSON.parse(decryptedString) as T;\n    } catch {\n        throw new Error(`Could not decrypt the given string (${encryptedString}).`);\n    }\n};\n"],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AAEO,MAAMA,OAAO,GAA6BC,SAA1B,IAAmD;EACtE,IAAI;IACA,OAAOC,MAAM,CAACC,IAAP,CAAYC,IAAI,CAACC,SAAL,CAAeJ,SAAf,CAAZ,EAAuC,OAAvC,EAAgDK,QAAhD,CAAyD,QAAzD,CAAP;EACH,CAFD,CAEE,MAAM;IACJ,MAAM,IAAIC,KAAJ,CAAU,+BAAV,CAAN;EACH;AACJ,CANM;;;;AAQA,MAAMC,OAAO,GAA6BC,eAA1B,IAAyD;EAC5E,IAAI;IACA,MAAMC,eAAe,GAAGR,MAAM,CAACC,IAAP,CAAYM,eAAZ,EAA6B,QAA7B,EAAuCH,QAAvC,CAAgD,OAAhD,CAAxB;IACA,OAAOF,IAAI,CAACO,KAAL,CAAWD,eAAX,CAAP;EACH,CAHD,CAGE,MAAM;IACJ,MAAM,IAAIH,KAAJ,CAAW,uCAAsCE,eAAgB,IAAjE,CAAN;EACH;AACJ,CAPM"}
+{"version":3,"names":["encrypt","rawObject","Buffer","from","JSON","stringify","toString","Error","exports","decrypt","encryptedString","decryptedString","parse"],"sources":["encryption.ts"],"sourcesContent":["/**\n * For now, we're not doing actual encryption, just simple base64 encoding/decoding.\n * Potentially, we'll revisit this in the future and implement actual encryption.\n */\n\nexport const encrypt = <T = Record<string, any>>(rawObject: T): string => {\n    try {\n        return Buffer.from(JSON.stringify(rawObject), \"utf-8\").toString(\"base64\");\n    } catch {\n        throw new Error(\"Could not encrypt given data.\");\n    }\n};\n\nexport const decrypt = <T = Record<string, any>>(encryptedString: string): T => {\n    try {\n        const decryptedString = Buffer.from(encryptedString, \"base64\").toString(\"utf-8\");\n        return JSON.parse(decryptedString) as T;\n    } catch {\n        throw new Error(`Could not decrypt the given string (${encryptedString}).`);\n    }\n};\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;;AAEO,MAAMA,OAAO,GAA6BC,SAAY,IAAa;EACtE,IAAI;IACA,OAAOC,MAAM,CAACC,IAAI,CAACC,IAAI,CAACC,SAAS,CAACJ,SAAS,CAAC,EAAE,OAAO,CAAC,CAACK,QAAQ,CAAC,QAAQ,CAAC;EAC7E,CAAC,CAAC,MAAM;IACJ,MAAM,IAAIC,KAAK,CAAC,+BAA+B,CAAC;EACpD;AACJ,CAAC;AAACC,OAAA,CAAAR,OAAA,GAAAA,OAAA;AAEK,MAAMS,OAAO,GAA6BC,eAAuB,IAAQ;EAC5E,IAAI;IACA,MAAMC,eAAe,GAAGT,MAAM,CAACC,IAAI,CAACO,eAAe,EAAE,QAAQ,CAAC,CAACJ,QAAQ,CAAC,OAAO,CAAC;IAChF,OAAOF,IAAI,CAACQ,KAAK,CAACD,eAAe,CAAC;EACtC,CAAC,CAAC,MAAM;IACJ,MAAM,IAAIJ,KAAK,CAAC,uCAAuCG,eAAe,IAAI,CAAC;EAC/E;AACJ,CAAC;AAACF,OAAA,CAAAC,OAAA,GAAAA,OAAA","ignoreList":[]}

package/getWcpProjectEnvironment.d.ts

@@ -0,0 +1,2 @@
+import type { WcpProjectEnvironment } from "./types";
+export declare function getWcpProjectEnvironment(): WcpProjectEnvironment | null;

package/getWcpProjectEnvironment.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getWcpProjectEnvironment = getWcpProjectEnvironment;
+var _encryption = require("./encryption");
+function getWcpProjectEnvironment() {
+  if (process.env.WCP_PROJECT_ENVIRONMENT) {
+    try {
+      return (0, _encryption.decrypt)(process.env.WCP_PROJECT_ENVIRONMENT);
+    } catch {
+      throw new Error("Could not decrypt WCP_PROJECT_ENVIRONMENT environment variable data.");
+    }
+  }
+  return null;
+}
+
+//# sourceMappingURL=getWcpProjectEnvironment.js.map

package/getWcpProjectEnvironment.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_encryption","require","getWcpProjectEnvironment","process","env","WCP_PROJECT_ENVIRONMENT","decrypt","Error"],"sources":["getWcpProjectEnvironment.ts"],"sourcesContent":["import type { WcpProjectEnvironment } from \"~/types\";\nimport { decrypt } from \"~/encryption\";\n\nexport function getWcpProjectEnvironment(): WcpProjectEnvironment | null {\n    if (process.env.WCP_PROJECT_ENVIRONMENT) {\n        try {\n            return decrypt<WcpProjectEnvironment>(process.env.WCP_PROJECT_ENVIRONMENT);\n        } catch {\n            throw new Error(\"Could not decrypt WCP_PROJECT_ENVIRONMENT environment variable data.\");\n        }\n    }\n    return null;\n}\n"],"mappings":";;;;;;AACA,IAAAA,WAAA,GAAAC,OAAA;AAEO,SAASC,wBAAwBA,CAAA,EAAiC;EACrE,IAAIC,OAAO,CAACC,GAAG,CAACC,uBAAuB,EAAE;IACrC,IAAI;MACA,OAAO,IAAAC,mBAAO,EAAwBH,OAAO,CAACC,GAAG,CAACC,uBAAuB,CAAC;IAC9E,CAAC,CAAC,MAAM;MACJ,MAAM,IAAIE,KAAK,CAAC,sEAAsE,CAAC;IAC3F;EACJ;EACA,OAAO,IAAI;AACf","ignoreList":[]}

package/index.d.ts

@@ -1,9 +1,15 @@
 export * from "./encryption";
 export * from "./licenses";
 export * from "./urls";
+export * from "./License.js";
+export * from "./NullLicense";
+export * from "./getWcpProjectEnvironment";
 export declare const WCP_FEATURE_LABEL: {
     seats: string;
     multiTenancy: string;
     advancedPublishingWorkflow: string;
     advancedAccessControlLayer: string;
+    auditLogs: string;
+    recordLocking: string;
+    fileManager: string;
 };

package/index.js

@@ -7,9 +7,7 @@ var _exportNames = {
   WCP_FEATURE_LABEL: true
 };
 exports.WCP_FEATURE_LABEL = void 0;
-
 var _encryption = require("./encryption");
-
 Object.keys(_encryption).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -21,9 +19,7 @@ Object.keys(_encryption).forEach(function (key) {
     }
   });
 });
-
 var _licenses = require("./licenses");
-
 Object.keys(_licenses).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -35,9 +31,7 @@ Object.keys(_licenses).forEach(function (key) {
     }
   });
 });
-
 var _urls = require("./urls");
-
 Object.keys(_urls).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
@@ -49,10 +43,50 @@ Object.keys(_urls).forEach(function (key) {
     }
   });
 });
-const WCP_FEATURE_LABEL = {
+var _License = require("./License.js");
+Object.keys(_License).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _License[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _License[key];
+    }
+  });
+});
+var _NullLicense = require("./NullLicense");
+Object.keys(_NullLicense).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _NullLicense[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _NullLicense[key];
+    }
+  });
+});
+var _getWcpProjectEnvironment = require("./getWcpProjectEnvironment");
+Object.keys(_getWcpProjectEnvironment).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getWcpProjectEnvironment[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getWcpProjectEnvironment[key];
+    }
+  });
+});
+const WCP_FEATURE_LABEL = exports.WCP_FEATURE_LABEL = {
   seats: "User Seats",
   multiTenancy: "Multi-tenancy",
   advancedPublishingWorkflow: "Advanced Publishing Workflow (APW)",
-  advancedAccessControlLayer: "Advanced Access Control Layer (ACL)"
+  advancedAccessControlLayer: "Advanced Access Control Layer (ACL)",
+  auditLogs: "Audit Logs",
+  recordLocking: "Record Locking",
+  fileManager: "File Manager"
 };
-exports.WCP_FEATURE_LABEL = WCP_FEATURE_LABEL;
+
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["WCP_FEATURE_LABEL","seats","multiTenancy","advancedPublishingWorkflow","advancedAccessControlLayer"],"sources":["index.ts"],"sourcesContent":["export * from \"./encryption\";\nexport * from \"./licenses\";\nexport * from \"./urls\";\n\nexport const WCP_FEATURE_LABEL = {\n    seats: \"User Seats\",\n    multiTenancy: \"Multi-tenancy\",\n    advancedPublishingWorkflow: \"Advanced Publishing Workflow (APW)\",\n    advancedAccessControlLayer: \"Advanced Access Control Layer (ACL)\"\n};\n"],"mappings":";;;;;;;;;;AAAA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;AAEO,MAAMA,iBAAiB,GAAG;EAC7BC,KAAK,EAAE,YADsB;EAE7BC,YAAY,EAAE,eAFe;EAG7BC,0BAA0B,EAAE,oCAHC;EAI7BC,0BAA0B,EAAE;AAJC,CAA1B"}
+{"version":3,"names":["_encryption","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_licenses","_urls","_License","_NullLicense","_getWcpProjectEnvironment","WCP_FEATURE_LABEL","seats","multiTenancy","advancedPublishingWorkflow","advancedAccessControlLayer","auditLogs","recordLocking","fileManager"],"sources":["index.ts"],"sourcesContent":["export * from \"./encryption\";\nexport * from \"./licenses\";\nexport * from \"./urls\";\nexport * from \"./License.js\";\nexport * from \"./NullLicense\";\nexport * from \"./getWcpProjectEnvironment\";\n\nexport const WCP_FEATURE_LABEL = {\n    seats: \"User Seats\",\n    multiTenancy: \"Multi-tenancy\",\n    advancedPublishingWorkflow: \"Advanced Publishing Workflow (APW)\",\n    advancedAccessControlLayer: \"Advanced Access Control Layer (ACL)\",\n    auditLogs: \"Audit Logs\",\n    recordLocking: \"Record Locking\",\n    fileManager: \"File Manager\"\n};\n"],"mappings":"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","ignoreList":[]}

package/licenses.d.ts

@@ -1,4 +1,4 @@
-import { DecryptedWcpProjectLicense } from "./types";
+import type { DecryptedWcpProjectLicense } from "./types";
 interface GetWcpProjectLicenseParams {
     orgId: string;
     projectId: string;

package/licenses.js

@@ -1,18 +1,13 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getWcpProjectLicense = void 0;
-
 var _nodeFetch = _interopRequireDefault(require("node-fetch"));
-
 var _encryption = require("./encryption");
-
 var _urls = require("./urls");
-
 const fetchWcpProjectLicense = async ({
   orgId,
   projectId,
@@ -24,28 +19,29 @@ const fetchWcpProjectLicense = async ({
     headers: {
       authorization: projectEnvironmentApiKey
     }
-  }).then(response => response.json()).catch(e => {
-    console.warn(`An error occurred while trying to retrieve the license for project "${orgId}/${projectId}": ${e.message}`);
+  }).then(response => {
+    if (response.ok) {
+      return response.json();
+    }
+    console.warn(`An error occurred while trying to retrieve the license for project "${orgId}/${projectId}": invalid response status (${response.status}, ${response.statusText})`, response);
+    return null;
+  }).catch(e => {
+    console.warn(`An error occurred while trying to retrieve the license for project "${orgId}/${projectId}": ${e.message}`, e);
     return null;
   });
   return encryptedLicense;
 };
-
 const getWcpProjectLicense = async params => {
   let encryptedLicense = process.env.WCP_PROJECT_LICENSE;
-
   if (!encryptedLicense) {
     const fetchedLicense = await fetchWcpProjectLicense(params);
-
     if (fetchedLicense) {
       encryptedLicense = fetchedLicense.license;
     }
   }
-
   if (!encryptedLicense) {
     return null;
   }
-
   try {
     return (0, _encryption.decrypt)(encryptedLicense);
   } catch (e) {
@@ -54,5 +50,6 @@ const getWcpProjectLicense = async params => {
     return null;
   }
 };
+exports.getWcpProjectLicense = getWcpProjectLicense;
 
-exports.getWcpProjectLicense = getWcpProjectLicense;
+//# sourceMappingURL=licenses.js.map

package/licenses.js.map

@@ -1 +1 @@
-{"version":3,"names":["fetchWcpProjectLicense","orgId","projectId","projectEnvironmentApiKey","getLicenseEndpoint","getWcpApiUrl","encryptedLicense","fetch","headers","authorization","then","response","json","catch","e","console","warn","message","getWcpProjectLicense","params","process","env","WCP_PROJECT_LICENSE","fetchedLicense","license","decrypt"],"sources":["licenses.ts"],"sourcesContent":["import fetch from \"node-fetch\";\nimport { DecryptedWcpProjectLicense, EncryptedWcpProjectLicense } from \"./types\";\nimport { decrypt } from \"./encryption\";\nimport { getWcpApiUrl } from \"./urls\";\n\ninterface GetWcpProjectLicenseParams {\n    orgId: string;\n    projectId: string;\n    projectEnvironmentApiKey: string;\n}\n\nconst fetchWcpProjectLicense = async ({\n    orgId,\n    projectId,\n    projectEnvironmentApiKey\n}: GetWcpProjectLicenseParams) => {\n    // Fetch and decrypt the license.\n    const getLicenseEndpoint = getWcpApiUrl(`/orgs/${orgId}/projects/${projectId}/license`);\n\n    const encryptedLicense: { license: EncryptedWcpProjectLicense } | null = await fetch(\n        getLicenseEndpoint,\n        {\n            headers: { authorization: projectEnvironmentApiKey }\n        }\n    )\n        .then(response => response.json())\n        .catch(e => {\n            console.warn(\n                `An error occurred while trying to retrieve the license for project \"${orgId}/${projectId}\": ${e.message}`\n            );\n            return null;\n        });\n\n    return encryptedLicense;\n};\n\nexport const getWcpProjectLicense = async (params: GetWcpProjectLicenseParams) => {\n    let encryptedLicense = process.env.WCP_PROJECT_LICENSE;\n    if (!encryptedLicense) {\n        const fetchedLicense = await fetchWcpProjectLicense(params);\n        if (fetchedLicense) {\n            encryptedLicense = fetchedLicense.license;\n        }\n    }\n\n    if (!encryptedLicense) {\n        return null;\n    }\n\n    try {\n        return decrypt<DecryptedWcpProjectLicense>(encryptedLicense);\n    } catch (e) {\n        const projectId = `${params.orgId}/${params.projectId}`;\n        console.warn(\n            `An error occurred while trying to decrypt the retrieved license for project \"${projectId}\": ${e.message}`\n        );\n        return null;\n    }\n};\n"],"mappings":";;;;;;;;;AAAA;;AAEA;;AACA;;AAQA,MAAMA,sBAAsB,GAAG,OAAO;EAClCC,KADkC;EAElCC,SAFkC;EAGlCC;AAHkC,CAAP,KAIG;EAC9B;EACA,MAAMC,kBAAkB,GAAG,IAAAC,kBAAA,EAAc,SAAQJ,KAAM,aAAYC,SAAU,UAAlD,CAA3B;EAEA,MAAMI,gBAAgE,GAAG,MAAM,IAAAC,kBAAA,EAC3EH,kBAD2E,EAE3E;IACII,OAAO,EAAE;MAAEC,aAAa,EAAEN;IAAjB;EADb,CAF2E,EAM1EO,IAN0E,CAMrEC,QAAQ,IAAIA,QAAQ,CAACC,IAAT,EANyD,EAO1EC,KAP0E,CAOpEC,CAAC,IAAI;IACRC,OAAO,CAACC,IAAR,CACK,uEAAsEf,KAAM,IAAGC,SAAU,MAAKY,CAAC,CAACG,OAAQ,EAD7G;IAGA,OAAO,IAAP;EACH,CAZ0E,CAA/E;EAcA,OAAOX,gBAAP;AACH,CAvBD;;AAyBO,MAAMY,oBAAoB,GAAG,MAAOC,MAAP,IAA8C;EAC9E,IAAIb,gBAAgB,GAAGc,OAAO,CAACC,GAAR,CAAYC,mBAAnC;;EACA,IAAI,CAAChB,gBAAL,EAAuB;IACnB,MAAMiB,cAAc,GAAG,MAAMvB,sBAAsB,CAACmB,MAAD,CAAnD;;IACA,IAAII,cAAJ,EAAoB;MAChBjB,gBAAgB,GAAGiB,cAAc,CAACC,OAAlC;IACH;EACJ;;EAED,IAAI,CAAClB,gBAAL,EAAuB;IACnB,OAAO,IAAP;EACH;;EAED,IAAI;IACA,OAAO,IAAAmB,mBAAA,EAAoCnB,gBAApC,CAAP;EACH,CAFD,CAEE,OAAOQ,CAAP,EAAU;IACR,MAAMZ,SAAS,GAAI,GAAEiB,MAAM,CAAClB,KAAM,IAAGkB,MAAM,CAACjB,SAAU,EAAtD;IACAa,OAAO,CAACC,IAAR,CACK,gFAA+Ed,SAAU,MAAKY,CAAC,CAACG,OAAQ,EAD7G;IAGA,OAAO,IAAP;EACH;AACJ,CAtBM"}
+{"version":3,"names":["_nodeFetch","_interopRequireDefault","require","_encryption","_urls","fetchWcpProjectLicense","orgId","projectId","projectEnvironmentApiKey","getLicenseEndpoint","getWcpApiUrl","encryptedLicense","fetch","headers","authorization","then","response","ok","json","console","warn","status","statusText","catch","e","message","getWcpProjectLicense","params","process","env","WCP_PROJECT_LICENSE","fetchedLicense","license","decrypt","exports"],"sources":["licenses.ts"],"sourcesContent":["import fetch from \"node-fetch\";\nimport type { DecryptedWcpProjectLicense, EncryptedWcpProjectLicense } from \"./types\";\nimport { decrypt } from \"./encryption\";\nimport { getWcpApiUrl } from \"./urls\";\n\ninterface GetWcpProjectLicenseParams {\n    orgId: string;\n    projectId: string;\n    projectEnvironmentApiKey: string;\n}\n\nconst fetchWcpProjectLicense = async ({\n    orgId,\n    projectId,\n    projectEnvironmentApiKey\n}: GetWcpProjectLicenseParams) => {\n    // Fetch and decrypt the license.\n    const getLicenseEndpoint = getWcpApiUrl(`/orgs/${orgId}/projects/${projectId}/license`);\n\n    const encryptedLicense: { license: EncryptedWcpProjectLicense } | null = await fetch(\n        getLicenseEndpoint,\n        {\n            headers: { authorization: projectEnvironmentApiKey }\n        }\n    )\n        .then(response => {\n            if (response.ok) {\n                return response.json();\n            }\n\n            console.warn(\n                `An error occurred while trying to retrieve the license for project \"${orgId}/${projectId}\": invalid response status (${response.status}, ${response.statusText})`,\n                response\n            );\n\n            return null;\n        })\n        .catch(e => {\n            console.warn(\n                `An error occurred while trying to retrieve the license for project \"${orgId}/${projectId}\": ${e.message}`,\n                e\n            );\n            return null;\n        });\n\n    return encryptedLicense;\n};\n\nexport const getWcpProjectLicense = async (params: GetWcpProjectLicenseParams) => {\n    let encryptedLicense = process.env.WCP_PROJECT_LICENSE;\n    if (!encryptedLicense) {\n        const fetchedLicense = await fetchWcpProjectLicense(params);\n        if (fetchedLicense) {\n            encryptedLicense = fetchedLicense.license;\n        }\n    }\n\n    if (!encryptedLicense) {\n        return null;\n    }\n\n    try {\n        return decrypt<DecryptedWcpProjectLicense>(encryptedLicense);\n    } catch (e) {\n        const projectId = `${params.orgId}/${params.projectId}`;\n        console.warn(\n            `An error occurred while trying to decrypt the retrieved license for project \"${projectId}\": ${e.message}`\n        );\n        return null;\n    }\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,UAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,WAAA,GAAAD,OAAA;AACA,IAAAE,KAAA,GAAAF,OAAA;AAQA,MAAMG,sBAAsB,GAAG,MAAAA,CAAO;EAClCC,KAAK;EACLC,SAAS;EACTC;AACwB,CAAC,KAAK;EAC9B;EACA,MAAMC,kBAAkB,GAAG,IAAAC,kBAAY,EAAC,SAASJ,KAAK,aAAaC,SAAS,UAAU,CAAC;EAEvF,MAAMI,gBAAgE,GAAG,MAAM,IAAAC,kBAAK,EAChFH,kBAAkB,EAClB;IACII,OAAO,EAAE;MAAEC,aAAa,EAAEN;IAAyB;EACvD,CACJ,CAAC,CACIO,IAAI,CAACC,QAAQ,IAAI;IACd,IAAIA,QAAQ,CAACC,EAAE,EAAE;MACb,OAAOD,QAAQ,CAACE,IAAI,CAAC,CAAC;IAC1B;IAEAC,OAAO,CAACC,IAAI,CACR,uEAAuEd,KAAK,IAAIC,SAAS,+BAA+BS,QAAQ,CAACK,MAAM,KAAKL,QAAQ,CAACM,UAAU,GAAG,EAClKN,QACJ,CAAC;IAED,OAAO,IAAI;EACf,CAAC,CAAC,CACDO,KAAK,CAACC,CAAC,IAAI;IACRL,OAAO,CAACC,IAAI,CACR,uEAAuEd,KAAK,IAAIC,SAAS,MAAMiB,CAAC,CAACC,OAAO,EAAE,EAC1GD,CACJ,CAAC;IACD,OAAO,IAAI;EACf,CAAC,CAAC;EAEN,OAAOb,gBAAgB;AAC3B,CAAC;AAEM,MAAMe,oBAAoB,GAAG,MAAOC,MAAkC,IAAK;EAC9E,IAAIhB,gBAAgB,GAAGiB,OAAO,CAACC,GAAG,CAACC,mBAAmB;EACtD,IAAI,CAACnB,gBAAgB,EAAE;IACnB,MAAMoB,cAAc,GAAG,MAAM1B,sBAAsB,CAACsB,MAAM,CAAC;IAC3D,IAAII,cAAc,EAAE;MAChBpB,gBAAgB,GAAGoB,cAAc,CAACC,OAAO;IAC7C;EACJ;EAEA,IAAI,CAACrB,gBAAgB,EAAE;IACnB,OAAO,IAAI;EACf;EAEA,IAAI;IACA,OAAO,IAAAsB,mBAAO,EAA6BtB,gBAAgB,CAAC;EAChE,CAAC,CAAC,OAAOa,CAAC,EAAE;IACR,MAAMjB,SAAS,GAAG,GAAGoB,MAAM,CAACrB,KAAK,IAAIqB,MAAM,CAACpB,SAAS,EAAE;IACvDY,OAAO,CAACC,IAAI,CACR,gFAAgFb,SAAS,MAAMiB,CAAC,CAACC,OAAO,EAC5G,CAAC;IACD,OAAO,IAAI;EACf;AACJ,CAAC;AAACS,OAAA,CAAAR,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/wcp",
-	"version": "0.0.0-unstable.df6d94b531",
+	"version": "0.0.0-unstable.e53eceafb5",
 	"main": "index.js",
 	"repository": {
 		"type": "git",
@@ -11,34 +11,25 @@
 	"author": "Webiny Ltd.",
 	"license": "MIT",
 	"dependencies": {
-		"@babel/runtime": "7.20.13",
-		"node-fetch": "2.6.9"
+		"node-fetch": "2.6.7"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.19.3",
-		"@babel/core": "^7.19.3",
-		"@babel/plugin-proposal-object-rest-spread": "^7.16.0",
-		"@babel/plugin-transform-runtime": "^7.16.4",
-		"@babel/preset-env": "^7.19.4",
-		"@babel/preset-typescript": "^7.18.6",
-		"@webiny/cli": "^0.0.0-unstable.df6d94b531",
-		"@webiny/project-utils": "^0.0.0-unstable.df6d94b531",
-		"rimraf": "^3.0.2",
-		"ttypescript": "^1.5.12",
-		"typescript": "4.7.4"
+		"@webiny/project-utils": "0.0.0-unstable.e53eceafb5",
+		"rimraf": "6.0.1",
+		"typescript": "5.3.3"
 	},
 	"publishConfig": {
 		"access": "public",
 		"directory": "dist"
 	},
 	"scripts": {
-		"watch": "yarn webiny run watch",
-		"build": "yarn webiny run build"
+		"watch": "node ../cli/bin.js run watch",
+		"build": "node ../cli/bin.js run build"
 	},
 	"adio": {
 		"ignoreDirs": [
 			"__tests__"
 		]
 	},
-	"gitHead": "df6d94b531ed0453caef22c785d42be580c9df96"
+	"gitHead": "e53eceafb5ce1a3872c9b4548939bb2eae5b1aef"
 }

package/testing/createTestWcpLicense.d.ts

@@ -0,0 +1,2 @@
+import type { DecryptedWcpProjectLicense } from "../types";
+export declare const createTestWcpLicense: () => DecryptedWcpProjectLicense;

package/testing/createTestWcpLicense.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTestWcpLicense = void 0;
+var _types = require("../types");
+const createTestWcpLicense = () => {
+  return {
+    orgId: "org-id",
+    projectId: "project-id",
+    package: {
+      features: {
+        [_types.PROJECT_PACKAGE_FEATURE_NAME.AACL]: {
+          enabled: true,
+          options: {
+            teams: true,
+            folderLevelPermissions: true,
+            privateFiles: true
+          }
+        },
+        [_types.PROJECT_PACKAGE_FEATURE_NAME.MT]: {
+          enabled: true,
+          options: {
+            maxCount: {
+              type: _types.MT_OPTIONS_MAX_COUNT_TYPE.SEAT_BASED
+            }
+          }
+        },
+        [_types.PROJECT_PACKAGE_FEATURE_NAME.APW]: {
+          enabled: false
+        },
+        [_types.PROJECT_PACKAGE_FEATURE_NAME.AUDIT_LOGS]: {
+          enabled: false
+        },
+        [_types.PROJECT_PACKAGE_FEATURE_NAME.RECORD_LOCKING]: {
+          enabled: false
+        },
+        [_types.PROJECT_PACKAGE_FEATURE_NAME.SEATS]: {
+          enabled: true,
+          options: {
+            maxCount: 100
+          }
+        },
+        [_types.PROJECT_PACKAGE_FEATURE_NAME.FILE_MANAGER]: {
+          enabled: false,
+          options: {
+            threatDetection: false
+          }
+        }
+      }
+    }
+  };
+};
+exports.createTestWcpLicense = createTestWcpLicense;
+
+//# sourceMappingURL=createTestWcpLicense.js.map

package/testing/createTestWcpLicense.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_types","require","createTestWcpLicense","orgId","projectId","package","features","PROJECT_PACKAGE_FEATURE_NAME","AACL","enabled","options","teams","folderLevelPermissions","privateFiles","MT","maxCount","type","MT_OPTIONS_MAX_COUNT_TYPE","SEAT_BASED","APW","AUDIT_LOGS","RECORD_LOCKING","SEATS","FILE_MANAGER","threatDetection","exports"],"sources":["createTestWcpLicense.ts"],"sourcesContent":["import type { DecryptedWcpProjectLicense } from \"~/types\";\nimport { MT_OPTIONS_MAX_COUNT_TYPE, PROJECT_PACKAGE_FEATURE_NAME } from \"~/types\";\n\nexport const createTestWcpLicense = (): DecryptedWcpProjectLicense => {\n    return {\n        orgId: \"org-id\",\n        projectId: \"project-id\",\n        package: {\n            features: {\n                [PROJECT_PACKAGE_FEATURE_NAME.AACL]: {\n                    enabled: true,\n                    options: {\n                        teams: true,\n                        folderLevelPermissions: true,\n                        privateFiles: true\n                    }\n                },\n                [PROJECT_PACKAGE_FEATURE_NAME.MT]: {\n                    enabled: true,\n                    options: {\n                        maxCount: {\n                            type: MT_OPTIONS_MAX_COUNT_TYPE.SEAT_BASED\n                        }\n                    }\n                },\n                [PROJECT_PACKAGE_FEATURE_NAME.APW]: {\n                    enabled: false\n                },\n                [PROJECT_PACKAGE_FEATURE_NAME.AUDIT_LOGS]: {\n                    enabled: false\n                },\n                [PROJECT_PACKAGE_FEATURE_NAME.RECORD_LOCKING]: {\n                    enabled: false\n                },\n                [PROJECT_PACKAGE_FEATURE_NAME.SEATS]: {\n                    enabled: true,\n                    options: {\n                        maxCount: 100\n                    }\n                },\n                [PROJECT_PACKAGE_FEATURE_NAME.FILE_MANAGER]: {\n                    enabled: false,\n                    options: {\n                        threatDetection: false\n                    }\n                }\n            }\n        }\n    };\n};\n"],"mappings":";;;;;;AACA,IAAAA,MAAA,GAAAC,OAAA;AAEO,MAAMC,oBAAoB,GAAGA,CAAA,KAAkC;EAClE,OAAO;IACHC,KAAK,EAAE,QAAQ;IACfC,SAAS,EAAE,YAAY;IACvBC,OAAO,EAAE;MACLC,QAAQ,EAAE;QACN,CAACC,mCAA4B,CAACC,IAAI,GAAG;UACjCC,OAAO,EAAE,IAAI;UACbC,OAAO,EAAE;YACLC,KAAK,EAAE,IAAI;YACXC,sBAAsB,EAAE,IAAI;YAC5BC,YAAY,EAAE;UAClB;QACJ,CAAC;QACD,CAACN,mCAA4B,CAACO,EAAE,GAAG;UAC/BL,OAAO,EAAE,IAAI;UACbC,OAAO,EAAE;YACLK,QAAQ,EAAE;cACNC,IAAI,EAAEC,gCAAyB,CAACC;YACpC;UACJ;QACJ,CAAC;QACD,CAACX,mCAA4B,CAACY,GAAG,GAAG;UAChCV,OAAO,EAAE;QACb,CAAC;QACD,CAACF,mCAA4B,CAACa,UAAU,GAAG;UACvCX,OAAO,EAAE;QACb,CAAC;QACD,CAACF,mCAA4B,CAACc,cAAc,GAAG;UAC3CZ,OAAO,EAAE;QACb,CAAC;QACD,CAACF,mCAA4B,CAACe,KAAK,GAAG;UAClCb,OAAO,EAAE,IAAI;UACbC,OAAO,EAAE;YACLK,QAAQ,EAAE;UACd;QACJ,CAAC;QACD,CAACR,mCAA4B,CAACgB,YAAY,GAAG;UACzCd,OAAO,EAAE,KAAK;UACdC,OAAO,EAAE;YACLc,eAAe,EAAE;UACrB;QACJ;MACJ;IACJ;EACJ,CAAC;AACL,CAAC;AAACC,OAAA,CAAAvB,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/types.d.ts

@@ -1,3 +1,20 @@
+import type { WCP_FEATURE_LABEL } from "./index";
+export interface WcpProject {
+    orgId: string;
+    projectId: string;
+}
+export interface ILicense {
+    getRawLicense: () => DecryptedWcpProjectLicense | null;
+    getProject(): WcpProject | null;
+    canUseFeature: (featureId: keyof typeof WCP_FEATURE_LABEL) => boolean;
+    canUseAacl: () => boolean;
+    canUseTeams: () => boolean;
+    canUseAuditLogs: () => boolean;
+    canUsePrivateFiles: () => boolean;
+    canUseFileManagerThreatDetection: () => boolean;
+    canUseFolderLevelPermissions: () => boolean;
+    canUseRecordLocking: () => boolean;
+}
 export declare type WcpProjectEnvironment = {
     id: string;
     apiKey: string;
@@ -9,26 +26,73 @@ export declare type WcpProjectEnvironment = {
     };
 };
 export declare type EncryptedWcpProjectLicense = string;
+export declare enum PROJECT_PACKAGE_FEATURE_NAME {
+    SEATS = "seats",
+    MT = "multiTenancy",
+    APW = "advancedPublishingWorkflow",
+    AACL = "advancedAccessControlLayer",
+    /**
+     * @deprecated Use `AUDIT_LOGS` instead.
+     */
+    AL = "auditLogs",
+    /**
+     * TODO: remove eslint disable when removing AL enum value.
+     */
+    AUDIT_LOGS = "auditLogs",
+    RECORD_LOCKING = "recordLocking",
+    FILE_MANAGER = "fileManager"
+}
+export declare enum MT_OPTIONS_MAX_COUNT_TYPE {
+    SEAT_BASED = "seatBased",
+    FIXED = "fixed"
+}
+export interface ProjectPackageFeatures {
+    [PROJECT_PACKAGE_FEATURE_NAME.SEATS]: {
+        enabled: true;
+        options: {
+            maxCount: number;
+        };
+    };
+    [PROJECT_PACKAGE_FEATURE_NAME.MT]: {
+        enabled: true;
+        options: {
+            maxCount: {
+                type: MT_OPTIONS_MAX_COUNT_TYPE;
+                count?: number;
+            };
+        };
+    };
+    [PROJECT_PACKAGE_FEATURE_NAME.APW]: {
+        enabled: boolean;
+    };
+    [PROJECT_PACKAGE_FEATURE_NAME.AUDIT_LOGS]: {
+        enabled: boolean;
+    };
+    [PROJECT_PACKAGE_FEATURE_NAME.RECORD_LOCKING]: {
+        enabled: boolean;
+    };
+    [PROJECT_PACKAGE_FEATURE_NAME.AACL]: {
+        enabled: boolean;
+        options: {
+            teams: boolean;
+            privateFiles: boolean;
+            folderLevelPermissions: boolean;
+        };
+    };
+    [PROJECT_PACKAGE_FEATURE_NAME.AL]: {
+        enabled: boolean;
+    };
+    [PROJECT_PACKAGE_FEATURE_NAME.FILE_MANAGER]: {
+        enabled: boolean;
+        options: {
+            threatDetection: boolean;
+        };
+    };
+}
 export interface DecryptedWcpProjectLicense {
     orgId: string;
     projectId: string;
     package: {
-        features: {
-            seats: {
-                enabled: true;
-                options: {
-                    maxCount: number;
-                };
-            };
-            multiTenancy: {
-                enabled: true;
-            };
-            advancedPublishingWorkflow: {
-                enabled: boolean;
-            };
-            advancedAccessControlLayer: {
-                enabled: boolean;
-            };
-        };
+        features: ProjectPackageFeatures;
     };
 }

package/types.js

@@ -2,4 +2,23 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+exports.PROJECT_PACKAGE_FEATURE_NAME = exports.MT_OPTIONS_MAX_COUNT_TYPE = void 0;
+let PROJECT_PACKAGE_FEATURE_NAME = exports.PROJECT_PACKAGE_FEATURE_NAME = /*#__PURE__*/function (PROJECT_PACKAGE_FEATURE_NAME) {
+  PROJECT_PACKAGE_FEATURE_NAME["SEATS"] = "seats";
+  PROJECT_PACKAGE_FEATURE_NAME["MT"] = "multiTenancy";
+  PROJECT_PACKAGE_FEATURE_NAME["APW"] = "advancedPublishingWorkflow";
+  PROJECT_PACKAGE_FEATURE_NAME["AACL"] = "advancedAccessControlLayer";
+  PROJECT_PACKAGE_FEATURE_NAME["AL"] = "auditLogs";
+  PROJECT_PACKAGE_FEATURE_NAME["AUDIT_LOGS"] = "auditLogs";
+  PROJECT_PACKAGE_FEATURE_NAME["RECORD_LOCKING"] = "recordLocking";
+  PROJECT_PACKAGE_FEATURE_NAME["FILE_MANAGER"] = "fileManager";
+  return PROJECT_PACKAGE_FEATURE_NAME;
+}({});
+let MT_OPTIONS_MAX_COUNT_TYPE = exports.MT_OPTIONS_MAX_COUNT_TYPE = /*#__PURE__*/function (MT_OPTIONS_MAX_COUNT_TYPE) {
+  MT_OPTIONS_MAX_COUNT_TYPE["SEAT_BASED"] = "seatBased";
+  MT_OPTIONS_MAX_COUNT_TYPE["FIXED"] = "fixed";
+  return MT_OPTIONS_MAX_COUNT_TYPE;
+}({});
+
+//# sourceMappingURL=types.js.map

package/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["export declare type WcpProjectEnvironment = {\n    id: string;\n    apiKey: string;\n    org: {\n        id: string;\n    };\n    project: {\n        id: string;\n    };\n};\n\nexport declare type EncryptedWcpProjectLicense = string;\n\nexport interface DecryptedWcpProjectLicense {\n    orgId: string;\n    projectId: string;\n    package: {\n        features: {\n            seats: {\n                // This is always true because WCP projects immediately get access to seats (by default 1 seat).\n                enabled: true;\n                options: {\n                    maxCount: number;\n                };\n            };\n            multiTenancy: {\n                // This is always true because WCP projects immediately get access to multi-tenancy.\n                enabled: true;\n            };\n            advancedPublishingWorkflow: {\n                enabled: boolean;\n            };\n            advancedAccessControlLayer: {\n                enabled: boolean;\n            };\n        };\n    };\n}\n"],"mappings":""}
+{"version":3,"names":["PROJECT_PACKAGE_FEATURE_NAME","exports","MT_OPTIONS_MAX_COUNT_TYPE"],"sources":["types.ts"],"sourcesContent":["import type { WCP_FEATURE_LABEL } from \"~/index\";\n\nexport interface WcpProject {\n    orgId: string;\n    projectId: string;\n}\n\nexport interface ILicense {\n    // TODO: identify all places where raw license data is being used and refactor.\n    getRawLicense: () => DecryptedWcpProjectLicense | null;\n    getProject(): WcpProject | null;\n    canUseFeature: (featureId: keyof typeof WCP_FEATURE_LABEL) => boolean;\n    canUseAacl: () => boolean;\n    canUseTeams: () => boolean;\n    canUseAuditLogs: () => boolean;\n    canUsePrivateFiles: () => boolean;\n    canUseFileManagerThreatDetection: () => boolean;\n    canUseFolderLevelPermissions: () => boolean;\n    canUseRecordLocking: () => boolean;\n}\n\nexport declare type WcpProjectEnvironment = {\n    id: string;\n    apiKey: string;\n    org: {\n        id: string;\n    };\n    project: {\n        id: string;\n    };\n};\n\nexport declare type EncryptedWcpProjectLicense = string;\n\nexport enum PROJECT_PACKAGE_FEATURE_NAME {\n    SEATS = \"seats\",\n    MT = \"multiTenancy\",\n    APW = \"advancedPublishingWorkflow\",\n    AACL = \"advancedAccessControlLayer\",\n    /**\n     * @deprecated Use `AUDIT_LOGS` instead.\n     */\n    AL = \"auditLogs\",\n    /**\n     * TODO: remove eslint disable when removing AL enum value.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values\n    AUDIT_LOGS = \"auditLogs\",\n    RECORD_LOCKING = \"recordLocking\",\n    FILE_MANAGER = \"fileManager\"\n}\n\nexport enum MT_OPTIONS_MAX_COUNT_TYPE {\n    SEAT_BASED = \"seatBased\",\n    FIXED = \"fixed\"\n}\n\nexport interface ProjectPackageFeatures {\n    [PROJECT_PACKAGE_FEATURE_NAME.SEATS]: {\n        // This is always true because WCP projects immediately get access to seats (by default 1 seat).\n        enabled: true;\n        options: {\n            maxCount: number;\n        };\n    };\n    [PROJECT_PACKAGE_FEATURE_NAME.MT]: {\n        // This is always true because WCP projects immediately get access to multi-tenancy.\n        enabled: true;\n        options: {\n            maxCount: {\n                type: MT_OPTIONS_MAX_COUNT_TYPE;\n                count?: number;\n            };\n        };\n    };\n    [PROJECT_PACKAGE_FEATURE_NAME.APW]: {\n        enabled: boolean;\n    };\n    [PROJECT_PACKAGE_FEATURE_NAME.AUDIT_LOGS]: {\n        enabled: boolean;\n    };\n    [PROJECT_PACKAGE_FEATURE_NAME.RECORD_LOCKING]: {\n        enabled: boolean;\n    };\n    [PROJECT_PACKAGE_FEATURE_NAME.AACL]: {\n        enabled: boolean;\n        options: { teams: boolean; privateFiles: boolean; folderLevelPermissions: boolean };\n    };\n    [PROJECT_PACKAGE_FEATURE_NAME.AL]: {\n        enabled: boolean;\n    };\n    [PROJECT_PACKAGE_FEATURE_NAME.FILE_MANAGER]: {\n        enabled: boolean;\n        options: { threatDetection: boolean };\n    };\n}\n\nexport interface DecryptedWcpProjectLicense {\n    orgId: string;\n    projectId: string;\n    package: {\n        features: ProjectPackageFeatures;\n    };\n}\n"],"mappings":";;;;;;IAkCYA,4BAA4B,GAAAC,OAAA,CAAAD,4BAAA,0BAA5BA,4BAA4B;EAA5BA,4BAA4B;EAA5BA,4BAA4B;EAA5BA,4BAA4B;EAA5BA,4BAA4B;EAA5BA,4BAA4B;EAA5BA,4BAA4B;EAA5BA,4BAA4B;EAA5BA,4BAA4B;EAAA,OAA5BA,4BAA4B;AAAA;AAAA,IAkB5BE,yBAAyB,GAAAD,OAAA,CAAAC,yBAAA,0BAAzBA,yBAAyB;EAAzBA,yBAAyB;EAAzBA,yBAAyB;EAAA,OAAzBA,yBAAyB;AAAA","ignoreList":[]}

package/urls.js

@@ -6,24 +6,20 @@ Object.defineProperty(exports, "__esModule", {
 exports.getWcpGqlApiUrl = exports.getWcpAppUrl = exports.getWcpApiUrl = void 0;
 const DEFAULT_WCP_API_URL = "https://api.webiny.com";
 const DEFAULT_WCP_APP_URL = "https://app.webiny.com";
-
 const getWcpApiUrl = path => {
   const apiUrl = process.env.WCP_API_URL || DEFAULT_WCP_API_URL;
   return path ? apiUrl + path : apiUrl;
 };
-
 exports.getWcpApiUrl = getWcpApiUrl;
-
 const getWcpGqlApiUrl = path => {
   const graphqlApi = getWcpApiUrl("/graphql");
   return path ? graphqlApi + path : graphqlApi;
 };
-
 exports.getWcpGqlApiUrl = getWcpGqlApiUrl;
-
 const getWcpAppUrl = path => {
   const appUrl = process.env.WCP_APP_URL || DEFAULT_WCP_APP_URL;
   return path ? appUrl + path : appUrl;
 };
+exports.getWcpAppUrl = getWcpAppUrl;
 
-exports.getWcpAppUrl = getWcpAppUrl;
+//# sourceMappingURL=urls.js.map

package/urls.js.map

@@ -1 +1 @@
-{"version":3,"names":["DEFAULT_WCP_API_URL","DEFAULT_WCP_APP_URL","getWcpApiUrl","path","apiUrl","process","env","WCP_API_URL","getWcpGqlApiUrl","graphqlApi","getWcpAppUrl","appUrl","WCP_APP_URL"],"sources":["urls.ts"],"sourcesContent":["const DEFAULT_WCP_API_URL = \"https://api.webiny.com\";\nconst DEFAULT_WCP_APP_URL = \"https://app.webiny.com\";\n\nexport const getWcpApiUrl = (path?: string) => {\n    const apiUrl = process.env.WCP_API_URL || DEFAULT_WCP_API_URL;\n    return path ? apiUrl + path : apiUrl;\n};\n\nexport const getWcpGqlApiUrl = (path?: string) => {\n    const graphqlApi = getWcpApiUrl(\"/graphql\");\n    return path ? graphqlApi + path : graphqlApi;\n};\n\nexport const getWcpAppUrl = (path?: string) => {\n    const appUrl = process.env.WCP_APP_URL || DEFAULT_WCP_APP_URL;\n    return path ? appUrl + path : appUrl;\n};\n"],"mappings":";;;;;;AAAA,MAAMA,mBAAmB,GAAG,wBAA5B;AACA,MAAMC,mBAAmB,GAAG,wBAA5B;;AAEO,MAAMC,YAAY,GAAIC,IAAD,IAAmB;EAC3C,MAAMC,MAAM,GAAGC,OAAO,CAACC,GAAR,CAAYC,WAAZ,IAA2BP,mBAA1C;EACA,OAAOG,IAAI,GAAGC,MAAM,GAAGD,IAAZ,GAAmBC,MAA9B;AACH,CAHM;;;;AAKA,MAAMI,eAAe,GAAIL,IAAD,IAAmB;EAC9C,MAAMM,UAAU,GAAGP,YAAY,CAAC,UAAD,CAA/B;EACA,OAAOC,IAAI,GAAGM,UAAU,GAAGN,IAAhB,GAAuBM,UAAlC;AACH,CAHM;;;;AAKA,MAAMC,YAAY,GAAIP,IAAD,IAAmB;EAC3C,MAAMQ,MAAM,GAAGN,OAAO,CAACC,GAAR,CAAYM,WAAZ,IAA2BX,mBAA1C;EACA,OAAOE,IAAI,GAAGQ,MAAM,GAAGR,IAAZ,GAAmBQ,MAA9B;AACH,CAHM"}
+{"version":3,"names":["DEFAULT_WCP_API_URL","DEFAULT_WCP_APP_URL","getWcpApiUrl","path","apiUrl","process","env","WCP_API_URL","exports","getWcpGqlApiUrl","graphqlApi","getWcpAppUrl","appUrl","WCP_APP_URL"],"sources":["urls.ts"],"sourcesContent":["const DEFAULT_WCP_API_URL = \"https://api.webiny.com\";\nconst DEFAULT_WCP_APP_URL = \"https://app.webiny.com\";\n\nexport const getWcpApiUrl = (path?: string) => {\n    const apiUrl = process.env.WCP_API_URL || DEFAULT_WCP_API_URL;\n    return path ? apiUrl + path : apiUrl;\n};\n\nexport const getWcpGqlApiUrl = (path?: string) => {\n    const graphqlApi = getWcpApiUrl(\"/graphql\");\n    return path ? graphqlApi + path : graphqlApi;\n};\n\nexport const getWcpAppUrl = (path?: string) => {\n    const appUrl = process.env.WCP_APP_URL || DEFAULT_WCP_APP_URL;\n    return path ? appUrl + path : appUrl;\n};\n"],"mappings":";;;;;;AAAA,MAAMA,mBAAmB,GAAG,wBAAwB;AACpD,MAAMC,mBAAmB,GAAG,wBAAwB;AAE7C,MAAMC,YAAY,GAAIC,IAAa,IAAK;EAC3C,MAAMC,MAAM,GAAGC,OAAO,CAACC,GAAG,CAACC,WAAW,IAAIP,mBAAmB;EAC7D,OAAOG,IAAI,GAAGC,MAAM,GAAGD,IAAI,GAAGC,MAAM;AACxC,CAAC;AAACI,OAAA,CAAAN,YAAA,GAAAA,YAAA;AAEK,MAAMO,eAAe,GAAIN,IAAa,IAAK;EAC9C,MAAMO,UAAU,GAAGR,YAAY,CAAC,UAAU,CAAC;EAC3C,OAAOC,IAAI,GAAGO,UAAU,GAAGP,IAAI,GAAGO,UAAU;AAChD,CAAC;AAACF,OAAA,CAAAC,eAAA,GAAAA,eAAA;AAEK,MAAME,YAAY,GAAIR,IAAa,IAAK;EAC3C,MAAMS,MAAM,GAAGP,OAAO,CAACC,GAAG,CAACO,WAAW,IAAIZ,mBAAmB;EAC7D,OAAOE,IAAI,GAAGS,MAAM,GAAGT,IAAI,GAAGS,MAAM;AACxC,CAAC;AAACJ,OAAA,CAAAG,YAAA,GAAAA,YAAA","ignoreList":[]}