@webiny/tenant-manager 0.0.0-unstable.0d717d18dd

package/LICENSE

@@ -0,0 +1,36 @@
+The Webiny Enterprise license (the “Enterprise License”)
+Copyright (c) 2021 Webiny Ltd.
+
+With regard to the Webiny Software:
+
+This software and associated documentation files (the "Software") may only be
+used in production, if you (and any entity that you represent) have agreed to,
+and are in compliance with, the Webiny Subscription Terms of Service, available
+at https://www.webiny.com/terms (the “Enterprise Terms”), or other
+agreement governing the use of the Software, as agreed by you and Webiny,
+and otherwise have a valid Webiny Enterprise license for the
+correct number of user seats. Subject to the foregoing sentence, you are free to
+modify this Software and publish patches to the Software. You agree that Webiny
+and/or its licensors (as applicable) retain all right, title and interest in and
+to all such modifications and/or patches, and all such modifications and/or
+patches may only be used, copied, modified, displayed, distributed, or otherwise
+exploited with a valid Webiny Enterprise license for the  correct
+number of user seats.  Notwithstanding the foregoing, you may copy and modify
+the Software for development and testing purposes, without requiring a
+subscription.  You agree that Webiny and/or its licensors (as applicable) retain
+all right, title and interest in and to all such modifications.  You are not
+granted any other rights beyond what is expressly stated herein.  Subject to the
+foregoing, it is forbidden to copy, merge, publish, distribute, sublicense,
+and/or sell the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+For all third party components incorporated into the Webiny Software, those
+components are licensed under the original license provided by the owner of the
+applicable component.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/tenant-manager
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/TenantManager.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const TenantManager: () => React.JSX.Element;

package/TenantManager.js

@@ -0,0 +1,11 @@
+import react from "react";
+import { Admin, Api } from "@webiny/project-aws";
+import { Wcp } from "@webiny/project";
+const TenantManager = ()=>/*#__PURE__*/ react.createElement(Wcp.CanUseMultiTenancy, null, /*#__PURE__*/ react.createElement(Api.Extension, {
+        src: import.meta.dirname + "/api/Extension.js"
+    }), /*#__PURE__*/ react.createElement(Admin.Extension, {
+        src: import.meta.dirname + "/admin/Extension.js"
+    }));
+export { TenantManager };
+
+//# sourceMappingURL=TenantManager.js.map

package/TenantManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TenantManager.js","sources":["../src/TenantManager.tsx"],"sourcesContent":["import React from \"react\";\nimport { Api, Admin } from \"@webiny/project-aws\";\nimport { Wcp } from \"@webiny/project\";\n\nexport const TenantManager = () => {\n    return (\n        <Wcp.CanUseMultiTenancy>\n            {/* Api extensions */}\n            <Api.Extension src={import.meta.dirname + \"/api/Extension.js\"} />\n\n            {/* Admin extensions */}\n            <Admin.Extension src={import.meta.dirname + \"/admin/Extension.js\"} />\n        </Wcp.CanUseMultiTenancy>\n    );\n};\n"],"names":["TenantManager","Wcp","Api","Admin"],"mappings":";;;AAIO,MAAMA,gBAAgB,IAClB,WAAP,GACI,oBAACC,IAAI,kBAAkB,sBAEnB,oBAACC,IAAI,SAAS;QAAC,KAAK,YAAY,OAAO,GAAG;sBAG1C,oBAACC,MAAM,SAAS;QAAC,KAAK,YAAY,OAAO,GAAG"}

package/admin/CurrentTenant/CurrentTenant.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+export declare const CurrentTenant: (({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element) & React.NamedExoticComponent<{
+    children: React.ReactNode;
+}> & {
+    readonly type: ({ children }: {
+        children: React.ReactNode;
+    }) => React.JSX.Element;
+};

package/admin/CurrentTenant/CurrentTenant.js

@@ -0,0 +1,25 @@
+import react, { useEffect } from "react";
+import { observer } from "mobx-react-lite";
+import { useFeature } from "@webiny/app/exports/admin";
+import { OverlayLoader } from "@webiny/admin-ui";
+import { CurrentTenantFeature } from "./feature.js";
+const CurrentTenant = observer(({ children })=>{
+    const { presenter } = useFeature(CurrentTenantFeature);
+    useEffect(()=>{
+        presenter.init();
+    }, []);
+    const vm = presenter.vm;
+    if (vm.loading) return /*#__PURE__*/ react.createElement(OverlayLoader, {
+        text: "Loading tenant..."
+    });
+    if (vm.error) return /*#__PURE__*/ react.createElement(OverlayLoader, {
+        text: vm.error.message
+    });
+    if (!vm.tenant) return /*#__PURE__*/ react.createElement(OverlayLoader, {
+        text: "Unable to load tenant!"
+    });
+    return /*#__PURE__*/ react.createElement(react.Fragment, null, children);
+});
+export { CurrentTenant };
+
+//# sourceMappingURL=CurrentTenant.js.map

package/admin/CurrentTenant/CurrentTenant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenant/CurrentTenant.js","sources":["../../../src/admin/CurrentTenant/CurrentTenant.tsx"],"sourcesContent":["import React, { useEffect } from \"react\";\nimport { observer } from \"mobx-react-lite\";\nimport { useFeature } from \"@webiny/app/exports/admin\";\nimport { OverlayLoader } from \"@webiny/admin-ui\";\nimport { CurrentTenantFeature } from \"./feature.js\";\n\nexport const CurrentTenant = observer(({ children }: { children: React.ReactNode }) => {\n    const { presenter } = useFeature(CurrentTenantFeature);\n\n    useEffect(() => {\n        presenter.init();\n    }, []);\n\n    const vm = presenter.vm;\n\n    if (vm.loading) {\n        return <OverlayLoader text={\"Loading tenant...\"} />;\n    }\n\n    if (vm.error) {\n        return <OverlayLoader text={vm.error.message} />;\n    }\n\n    if (!vm.tenant) {\n        return <OverlayLoader text={\"Unable to load tenant!\"} />;\n    }\n\n    return <>{children}</>;\n});\n"],"names":["CurrentTenant","observer","children","presenter","useFeature","CurrentTenantFeature","useEffect","vm","OverlayLoader"],"mappings":";;;;;AAMO,MAAMA,gBAAgBC,SAAS,CAAC,EAAEC,QAAQ,EAAiC;IAC9E,MAAM,EAAEC,SAAS,EAAE,GAAGC,WAAWC;IAEjCC,UAAU;QACNH,UAAU,IAAI;IAClB,GAAG,EAAE;IAEL,MAAMI,KAAKJ,UAAU,EAAE;IAEvB,IAAII,GAAG,OAAO,EACV,OAAO,WAAP,GAAO,oBAACC,eAAaA;QAAC,MAAM;;IAGhC,IAAID,GAAG,KAAK,EACR,OAAO,WAAP,GAAO,oBAACC,eAAaA;QAAC,MAAMD,GAAG,KAAK,CAAC,OAAO;;IAGhD,IAAI,CAACA,GAAG,MAAM,EACV,OAAO,WAAP,GAAO,oBAACC,eAAaA;QAAC,MAAM;;IAGhC,OAAO,WAAP,GAAO,0CAAGN;AACd"}

package/admin/CurrentTenant/CurrentTenantGateway.d.ts

@@ -0,0 +1,12 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { CurrentTenantGateway as GatewayAbstraction } from "./abstractions.js";
+import { Tenant } from "../../shared/Tenant.js";
+declare class CurrentTenantGraphQLGateway implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    getTenant(): Promise<Tenant>;
+}
+export declare const CurrentTenantGateway: typeof CurrentTenantGraphQLGateway & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICurrentTenantGateway>;
+};
+export {};

package/admin/CurrentTenant/CurrentTenantGateway.js

@@ -0,0 +1,43 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { CurrentTenantGateway } from "./abstractions.js";
+import { Tenant } from "../../shared/Tenant.js";
+const GET_CURRENT_TENANT = `
+    query GetCurrentTenant {
+        tenantManager {
+            getCurrentTenant {
+                data {
+                    id
+                    values
+                }
+                error {
+                    code
+                    message
+                    data
+                }
+            }
+        }
+    }
+`;
+class CurrentTenantGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async getTenant() {
+        const response = await this.client.execute({
+            query: GET_CURRENT_TENANT
+        });
+        const envelope = response.tenantManager.getCurrentTenant;
+        if (envelope.error) throw new Error(envelope.error.message);
+        if (!envelope.data) throw new Error("Unable to load tenant");
+        return Tenant.from(envelope.data);
+    }
+}
+const CurrentTenantGateway_CurrentTenantGateway = CurrentTenantGateway.createImplementation({
+    implementation: CurrentTenantGraphQLGateway,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { CurrentTenantGateway_CurrentTenantGateway as CurrentTenantGateway };
+
+//# sourceMappingURL=CurrentTenantGateway.js.map

package/admin/CurrentTenant/CurrentTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenant/CurrentTenantGateway.js","sources":["../../../src/admin/CurrentTenant/CurrentTenantGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/index.js\";\nimport { CurrentTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport { Tenant, type TenantDto } from \"../../shared/Tenant.js\";\n\nconst GET_CURRENT_TENANT = /* GraphQL */ `\n    query GetCurrentTenant {\n        tenantManager {\n            getCurrentTenant {\n                data {\n                    id\n                    values\n                }\n                error {\n                    code\n                    message\n                    data\n                }\n            }\n        }\n    }\n`;\n\ntype GetCurrentTenantResponse = {\n    tenantManager: {\n        getCurrentTenant:\n            | {\n                  data: TenantDto;\n                  error: null;\n              }\n            | {\n                  data: null;\n                  error: {\n                      code: string;\n                      message: string;\n                      data: Record<string, any>;\n                  };\n              };\n    };\n};\n\nclass CurrentTenantGraphQLGateway implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async getTenant(): Promise<Tenant> {\n        const response = await this.client.execute<GetCurrentTenantResponse>({\n            query: GET_CURRENT_TENANT\n        });\n\n        const envelope = response.tenantManager.getCurrentTenant;\n        if (envelope.error) {\n            throw new Error(envelope.error.message);\n        }\n\n        if (!envelope.data) {\n            throw new Error(\"Unable to load tenant\");\n        }\n\n        return Tenant.from(envelope.data);\n    }\n}\n\nexport const CurrentTenantGateway = GatewayAbstraction.createImplementation({\n    implementation: CurrentTenantGraphQLGateway,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["GET_CURRENT_TENANT","CurrentTenantGraphQLGateway","client","response","envelope","Error","Tenant","CurrentTenantGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;;AAIA,MAAMA,qBAAmC,CAAC;;;;;;;;;;;;;;;;AAgB1C,CAAC;AAoBD,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,YAA6B;QAC/B,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAA2B;YACjE,OAAOH;QACX;QAEA,MAAMI,WAAWD,SAAS,aAAa,CAAC,gBAAgB;QACxD,IAAIC,SAAS,KAAK,EACd,MAAM,IAAIC,MAAMD,SAAS,KAAK,CAAC,OAAO;QAG1C,IAAI,CAACA,SAAS,IAAI,EACd,MAAM,IAAIC,MAAM;QAGpB,OAAOC,OAAO,IAAI,CAACF,SAAS,IAAI;IACpC;AACJ;AAEO,MAAMG,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/admin/CurrentTenant/CurrentTenantPresenter.d.ts

@@ -0,0 +1,12 @@
+import { CurrentTenantPresenter as PresenterAbstraction, CurrentTenantRepository } from "./abstractions.js";
+declare class CurrentTenantPresenterImpl implements PresenterAbstraction.Interface {
+    private repository;
+    private loading;
+    constructor(repository: CurrentTenantRepository.Interface);
+    get vm(): PresenterAbstraction.ViewModel;
+    init(): void;
+}
+export declare const CurrentTenantPresenter: typeof CurrentTenantPresenterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICurrentTenantPresenter>;
+};
+export {};

package/admin/CurrentTenant/CurrentTenantPresenter.js

@@ -0,0 +1,33 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { CurrentTenantPresenter, CurrentTenantRepository } from "./abstractions.js";
+class CurrentTenantPresenterImpl {
+    constructor(repository){
+        this.repository = repository;
+        this.loading = false;
+        makeAutoObservable(this);
+    }
+    get vm() {
+        return {
+            loading: this.loading,
+            tenant: this.repository.getTenant(),
+            error: this.repository.getError()
+        };
+    }
+    init() {
+        this.loading = true;
+        this.repository.loadTenant().then(()=>{
+            runInAction(()=>{
+                this.loading = false;
+            });
+        });
+    }
+}
+const CurrentTenantPresenter_CurrentTenantPresenter = CurrentTenantPresenter.createImplementation({
+    implementation: CurrentTenantPresenterImpl,
+    dependencies: [
+        CurrentTenantRepository
+    ]
+});
+export { CurrentTenantPresenter_CurrentTenantPresenter as CurrentTenantPresenter };
+
+//# sourceMappingURL=CurrentTenantPresenter.js.map

package/admin/CurrentTenant/CurrentTenantPresenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenant/CurrentTenantPresenter.js","sources":["../../../src/admin/CurrentTenant/CurrentTenantPresenter.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport {\n    CurrentTenantPresenter as PresenterAbstraction,\n    CurrentTenantRepository\n} from \"./abstractions.js\";\n\nclass CurrentTenantPresenterImpl implements PresenterAbstraction.Interface {\n    private loading = false;\n\n    constructor(private repository: CurrentTenantRepository.Interface) {\n        makeAutoObservable(this);\n    }\n\n    get vm(): PresenterAbstraction.ViewModel {\n        return {\n            loading: this.loading,\n            tenant: this.repository.getTenant(),\n            error: this.repository.getError()\n        };\n    }\n\n    init(): void {\n        this.loading = true;\n        this.repository.loadTenant().then(() => {\n            runInAction(() => {\n                this.loading = false;\n            });\n        });\n    }\n}\n\nexport const CurrentTenantPresenter = PresenterAbstraction.createImplementation({\n    implementation: CurrentTenantPresenterImpl,\n    dependencies: [CurrentTenantRepository]\n});\n"],"names":["CurrentTenantPresenterImpl","repository","makeAutoObservable","runInAction","CurrentTenantPresenter","PresenterAbstraction","CurrentTenantRepository"],"mappings":";;AAMA,MAAMA;IAGF,YAAoBC,UAA6C,CAAE;aAA/CA,UAAU,GAAVA;aAFZ,OAAO,GAAG;QAGdC,mBAAmB,IAAI;IAC3B;IAEA,IAAI,KAAqC;QACrC,OAAO;YACH,SAAS,IAAI,CAAC,OAAO;YACrB,QAAQ,IAAI,CAAC,UAAU,CAAC,SAAS;YACjC,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ;QACnC;IACJ;IAEA,OAAa;QACT,IAAI,CAAC,OAAO,GAAG;QACf,IAAI,CAAC,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC;YAC9BC,YAAY;gBACR,IAAI,CAAC,OAAO,GAAG;YACnB;QACJ;IACJ;AACJ;AAEO,MAAMC,gDAAyBC,uBAAAA,oBAAyC,CAAC;IAC5E,gBAAgBL;IAChB,cAAc;QAACM;KAAwB;AAC3C"}

package/admin/CurrentTenant/CurrentTenantRepository.d.ts

@@ -0,0 +1,15 @@
+import { CurrentTenantRepository as RepositoryAbstraction, CurrentTenantGateway } from "./abstractions.js";
+import type { Tenant } from "../../shared/Tenant.js";
+declare class CurrentTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private tenant;
+    private error;
+    constructor(gateway: CurrentTenantGateway.Interface);
+    getTenant(): Tenant | undefined;
+    getError(): Error | undefined;
+    loadTenant(): Promise<void>;
+}
+export declare const CurrentTenantRepository: typeof CurrentTenantRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICurrentTenantRepository>;
+};
+export {};

package/admin/CurrentTenant/CurrentTenantRepository.js

@@ -0,0 +1,38 @@
+import { makeAutoObservable, runInAction } from "mobx";
+import { CurrentTenantGateway, CurrentTenantRepository } from "./abstractions.js";
+class CurrentTenantRepositoryImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+        this.tenant = void 0;
+        this.error = void 0;
+        makeAutoObservable(this);
+    }
+    getTenant() {
+        return this.tenant;
+    }
+    getError() {
+        return this.error;
+    }
+    async loadTenant() {
+        if (this.tenant) return;
+        try {
+            const tenant = await this.gateway.getTenant();
+            runInAction(()=>{
+                this.tenant = tenant;
+            });
+        } catch (err) {
+            runInAction(()=>{
+                this.error = err instanceof Error ? err : new Error(String(err));
+            });
+        }
+    }
+}
+const CurrentTenantRepository_CurrentTenantRepository = CurrentTenantRepository.createImplementation({
+    implementation: CurrentTenantRepositoryImpl,
+    dependencies: [
+        CurrentTenantGateway
+    ]
+});
+export { CurrentTenantRepository_CurrentTenantRepository as CurrentTenantRepository };
+
+//# sourceMappingURL=CurrentTenantRepository.js.map

package/admin/CurrentTenant/CurrentTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenant/CurrentTenantRepository.js","sources":["../../../src/admin/CurrentTenant/CurrentTenantRepository.ts"],"sourcesContent":["import { makeAutoObservable, runInAction } from \"mobx\";\nimport {\n    CurrentTenantRepository as RepositoryAbstraction,\n    CurrentTenantGateway\n} from \"./abstractions.js\";\nimport type { Tenant } from \"../../shared/Tenant.js\";\n\nclass CurrentTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    private tenant: Tenant | undefined = undefined;\n    private error: Error | undefined = undefined;\n\n    constructor(private gateway: CurrentTenantGateway.Interface) {\n        makeAutoObservable(this);\n    }\n\n    getTenant(): Tenant | undefined {\n        return this.tenant;\n    }\n\n    getError(): Error | undefined {\n        return this.error;\n    }\n\n    async loadTenant(): Promise<void> {\n        if (this.tenant) {\n            return;\n        }\n\n        try {\n            const tenant = await this.gateway.getTenant();\n            runInAction(() => {\n                this.tenant = tenant;\n            });\n        } catch (err) {\n            runInAction(() => {\n                this.error = err instanceof Error ? err : new Error(String(err));\n            });\n        }\n    }\n}\n\nexport const CurrentTenantRepository = RepositoryAbstraction.createImplementation({\n    implementation: CurrentTenantRepositoryImpl,\n    dependencies: [CurrentTenantGateway]\n});\n"],"names":["CurrentTenantRepositoryImpl","gateway","undefined","makeAutoObservable","tenant","runInAction","err","Error","String","CurrentTenantRepository","RepositoryAbstraction","CurrentTenantGateway"],"mappings":";;AAOA,MAAMA;IAIF,YAAoBC,OAAuC,CAAE;aAAzCA,OAAO,GAAPA;aAHZ,MAAM,GAAuBC;aAC7B,KAAK,GAAsBA;QAG/BC,mBAAmB,IAAI;IAC3B;IAEA,YAAgC;QAC5B,OAAO,IAAI,CAAC,MAAM;IACtB;IAEA,WAA8B;QAC1B,OAAO,IAAI,CAAC,KAAK;IACrB;IAEA,MAAM,aAA4B;QAC9B,IAAI,IAAI,CAAC,MAAM,EACX;QAGJ,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS;YAC3CC,YAAY;gBACR,IAAI,CAAC,MAAM,GAAGD;YAClB;QACJ,EAAE,OAAOE,KAAK;YACVD,YAAY;gBACR,IAAI,CAAC,KAAK,GAAGC,eAAeC,QAAQD,MAAM,IAAIC,MAAMC,OAAOF;YAC/D;QACJ;IACJ;AACJ;AAEO,MAAMG,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBV;IAChB,cAAc;QAACW;KAAqB;AACxC"}

package/admin/CurrentTenant/abstractions.d.ts

@@ -0,0 +1,31 @@
+import type { Tenant } from "../../shared/Tenant.js";
+export interface ICurrentTenantVm {
+    loading: boolean;
+    tenant: Tenant | undefined;
+    error: Error | undefined;
+}
+export interface ICurrentTenantPresenter {
+    vm: ICurrentTenantVm;
+    init(): void;
+}
+export declare const CurrentTenantPresenter: import("@webiny/di").Abstraction<ICurrentTenantPresenter>;
+export declare namespace CurrentTenantPresenter {
+    type Interface = ICurrentTenantPresenter;
+    type ViewModel = ICurrentTenantVm;
+}
+export interface ICurrentTenantRepository {
+    getTenant(): Tenant | undefined;
+    getError(): Error | undefined;
+    loadTenant(): Promise<void>;
+}
+export declare const CurrentTenantRepository: import("@webiny/di").Abstraction<ICurrentTenantRepository>;
+export declare namespace CurrentTenantRepository {
+    type Interface = ICurrentTenantRepository;
+}
+export interface ICurrentTenantGateway {
+    getTenant(): Promise<Tenant>;
+}
+export declare const CurrentTenantGateway: import("@webiny/di").Abstraction<ICurrentTenantGateway>;
+export declare namespace CurrentTenantGateway {
+    type Interface = ICurrentTenantGateway;
+}

package/admin/CurrentTenant/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const CurrentTenantPresenter = createAbstraction("CurrentTenantPresenter");
+const CurrentTenantRepository = createAbstraction("CurrentTenantRepository");
+const CurrentTenantGateway = createAbstraction("CurrentTenantGateway");
+export { CurrentTenantGateway, CurrentTenantPresenter, CurrentTenantRepository };
+
+//# sourceMappingURL=abstractions.js.map

package/admin/CurrentTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenant/abstractions.js","sources":["../../../src/admin/CurrentTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\nimport type { Tenant } from \"../../shared/Tenant.js\";\n\n// Presenter\nexport interface ICurrentTenantVm {\n    loading: boolean;\n    tenant: Tenant | undefined;\n    error: Error | undefined;\n}\n\nexport interface ICurrentTenantPresenter {\n    vm: ICurrentTenantVm;\n    init(): void;\n}\n\nexport const CurrentTenantPresenter =\n    createAbstraction<ICurrentTenantPresenter>(\"CurrentTenantPresenter\");\n\nexport namespace CurrentTenantPresenter {\n    export type Interface = ICurrentTenantPresenter;\n    export type ViewModel = ICurrentTenantVm;\n}\n\n// Repository\nexport interface ICurrentTenantRepository {\n    getTenant(): Tenant | undefined;\n    getError(): Error | undefined;\n    loadTenant(): Promise<void>;\n}\n\nexport const CurrentTenantRepository =\n    createAbstraction<ICurrentTenantRepository>(\"CurrentTenantRepository\");\n\nexport namespace CurrentTenantRepository {\n    export type Interface = ICurrentTenantRepository;\n}\n\n// Gateway\nexport interface ICurrentTenantGateway {\n    getTenant(): Promise<Tenant>;\n}\n\nexport const CurrentTenantGateway =\n    createAbstraction<ICurrentTenantGateway>(\"CurrentTenantGateway\");\n\nexport namespace CurrentTenantGateway {\n    export type Interface = ICurrentTenantGateway;\n}\n"],"names":["CurrentTenantPresenter","createAbstraction","CurrentTenantRepository","CurrentTenantGateway"],"mappings":";AAeO,MAAMA,yBACTC,kBAA2C;AAcxC,MAAMC,0BACTD,kBAA4C;AAWzC,MAAME,uBACTF,kBAAyC"}

package/admin/CurrentTenant/feature.d.ts

@@ -0,0 +1,3 @@
+export declare const CurrentTenantFeature: import("@webiny/feature/admin").FeatureDefinition<{
+    presenter: import("./abstractions.js").ICurrentTenantPresenter;
+}, []>;

package/admin/CurrentTenant/feature.js

@@ -0,0 +1,21 @@
+import { createFeature } from "@webiny/feature/admin";
+import { CurrentTenantPresenter } from "./abstractions.js";
+import { CurrentTenantPresenter as external_CurrentTenantPresenter_js_CurrentTenantPresenter } from "./CurrentTenantPresenter.js";
+import { CurrentTenantRepository } from "./CurrentTenantRepository.js";
+import { CurrentTenantGateway } from "./CurrentTenantGateway.js";
+const CurrentTenantFeature = createFeature({
+    name: "CurrentTenant",
+    register (container) {
+        container.register(external_CurrentTenantPresenter_js_CurrentTenantPresenter);
+        container.register(CurrentTenantRepository).inSingletonScope();
+        container.register(CurrentTenantGateway).inSingletonScope();
+    },
+    resolve (container) {
+        return {
+            presenter: container.resolve(CurrentTenantPresenter)
+        };
+    }
+});
+export { CurrentTenantFeature };
+
+//# sourceMappingURL=feature.js.map

package/admin/CurrentTenant/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenant/feature.js","sources":["../../../src/admin/CurrentTenant/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/admin\";\nimport { CurrentTenantPresenter as PresenterAbstraction } from \"./abstractions.js\";\nimport { CurrentTenantPresenter } from \"./CurrentTenantPresenter.js\";\nimport { CurrentTenantRepository } from \"./CurrentTenantRepository.js\";\nimport { CurrentTenantGateway } from \"./CurrentTenantGateway.js\";\n\nexport const CurrentTenantFeature = createFeature({\n    name: \"CurrentTenant\",\n    register(container) {\n        container.register(CurrentTenantPresenter);\n        container.register(CurrentTenantRepository).inSingletonScope();\n        container.register(CurrentTenantGateway).inSingletonScope();\n    },\n    resolve(container) {\n        return {\n            presenter: container.resolve(PresenterAbstraction)\n        };\n    }\n});\n"],"names":["CurrentTenantFeature","createFeature","container","CurrentTenantPresenter","CurrentTenantRepository","CurrentTenantGateway","PresenterAbstraction"],"mappings":";;;;;AAMO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;QAC5DF,UAAU,QAAQ,CAACG,sBAAsB,gBAAgB;IAC7D;IACA,SAAQH,SAAS;QACb,OAAO;YACH,WAAWA,UAAU,OAAO,CAACI;QACjC;IACJ;AACJ"}

package/admin/CurrentTenant/useCurrentTenant.d.ts

@@ -0,0 +1,4 @@
+import type { Tenant } from "../../shared/Tenant.js";
+export declare const useCurrentTenant: () => {
+    tenant: Tenant;
+};

package/admin/CurrentTenant/useCurrentTenant.js

@@ -0,0 +1,18 @@
+import { useEffect, useState } from "react";
+import { autorun } from "mobx";
+import { useFeature } from "@webiny/app-admin";
+import { CurrentTenantFeature } from "./feature.js";
+const useCurrentTenant = ()=>{
+    const { presenter } = useFeature(CurrentTenantFeature);
+    const [tenant, setTenant] = useState(presenter.vm.tenant);
+    useEffect(()=>autorun(()=>{
+            const tenant = presenter.vm.tenant;
+            setTenant(tenant);
+        }), []);
+    return {
+        tenant
+    };
+};
+export { useCurrentTenant };
+
+//# sourceMappingURL=useCurrentTenant.js.map

package/admin/CurrentTenant/useCurrentTenant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenant/useCurrentTenant.js","sources":["../../../src/admin/CurrentTenant/useCurrentTenant.ts"],"sourcesContent":["import { useEffect, useState } from \"react\";\nimport { autorun } from \"mobx\";\nimport { useFeature } from \"@webiny/app-admin\";\nimport { CurrentTenantFeature } from \"./feature.js\";\nimport type { Tenant } from \"../../shared/Tenant.js\";\n\nexport const useCurrentTenant = () => {\n    const { presenter } = useFeature(CurrentTenantFeature);\n    // The app is not rendered till the tenant is loaded.\n    // If this hook is used, it's safe to assume the tenant is loaded.\n    const [tenant, setTenant] = useState(presenter.vm.tenant as Tenant);\n\n    useEffect(() => {\n        return autorun(() => {\n            const tenant = presenter.vm.tenant;\n            setTenant(tenant as Tenant);\n        });\n    }, []);\n\n    return { tenant };\n};\n"],"names":["useCurrentTenant","presenter","useFeature","CurrentTenantFeature","tenant","setTenant","useState","useEffect","autorun"],"mappings":";;;;AAMO,MAAMA,mBAAmB;IAC5B,MAAM,EAAEC,SAAS,EAAE,GAAGC,WAAWC;IAGjC,MAAM,CAACC,QAAQC,UAAU,GAAGC,SAASL,UAAU,EAAE,CAAC,MAAM;IAExDM,UAAU,IACCC,QAAQ;YACX,MAAMJ,SAASH,UAAU,EAAE,CAAC,MAAM;YAClCI,UAAUD;QACd,IACD,EAAE;IAEL,OAAO;QAAEA;IAAO;AACpB"}

package/admin/CurrentTenantProvider.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const CurrentTenantProvider: () => React.JSX.Element;

package/admin/CurrentTenantProvider.js

@@ -0,0 +1,9 @@
+import react from "react";
+import { createProviderPlugin } from "@webiny/app-admin";
+import { CurrentTenant } from "./CurrentTenant/CurrentTenant.js";
+const CurrentTenantProvider_CurrentTenantProvider = createProviderPlugin((Component)=>function({ children }) {
+        return /*#__PURE__*/ react.createElement(CurrentTenant, null, /*#__PURE__*/ react.createElement(Component, null, children));
+    });
+export { CurrentTenantProvider_CurrentTenantProvider as CurrentTenantProvider };
+
+//# sourceMappingURL=CurrentTenantProvider.js.map

package/admin/CurrentTenantProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/CurrentTenantProvider.js","sources":["../../src/admin/CurrentTenantProvider.tsx"],"sourcesContent":["import React from \"react\";\nimport { createProviderPlugin } from \"@webiny/app-admin\";\nimport { CurrentTenant } from \"./CurrentTenant/CurrentTenant.js\";\n\nexport const CurrentTenantProvider = createProviderPlugin(Component => {\n    return function CurrentTenantProvider({ children }) {\n        return (\n            <CurrentTenant>\n                <Component>{children}</Component>\n            </CurrentTenant>\n        );\n    };\n});\n"],"names":["CurrentTenantProvider","createProviderPlugin","Component","children","CurrentTenant"],"mappings":";;;AAIO,MAAMA,8CAAwBC,qBAAqBC,CAAAA,YAC/C,SAA+B,EAAEC,QAAQ,EAAE;QAC9C,OAAO,WAAP,GACI,oBAACC,eAAaA,MAAAA,WAAAA,GACV,oBAACF,WAAAA,MAAWC;IAGxB"}

package/admin/DisableTenant/DisableTenantGateway.d.ts

@@ -0,0 +1,11 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { DisableTenantGateway as GatewayAbstraction } from "./abstractions.js";
+declare class DisableTenantGraphQLGateway implements GatewayAbstraction.Interface {
+    private client;
+    constructor(client: MainGraphQLClient.Interface);
+    disableTenant(tenantId: string): Promise<boolean>;
+}
+export declare const DisableTenantGateway: typeof DisableTenantGraphQLGateway & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDisableTenantGateway>;
+};
+export {};

package/admin/DisableTenant/DisableTenantGateway.js

@@ -0,0 +1,42 @@
+import { MainGraphQLClient } from "@webiny/app/features/mainGraphQLClient/index.js";
+import { DisableTenantGateway } from "./abstractions.js";
+const DISABLE_TENANT = `
+    mutation DisableTenant($tenantId: ID!) {
+        tenantManager {
+            disableTenant(tenantId: $tenantId) {
+                data
+                error {
+                    code
+                    message
+                    data
+                }
+            }
+        }
+    }
+`;
+class DisableTenantGraphQLGateway {
+    constructor(client){
+        this.client = client;
+    }
+    async disableTenant(tenantId) {
+        const response = await this.client.execute({
+            query: DISABLE_TENANT,
+            variables: {
+                tenantId
+            }
+        });
+        const envelope = response.tenantManager.disableTenant;
+        if (envelope.error) throw new Error(envelope.error.message);
+        if (!envelope.data) throw new Error("Unable to disable tenant");
+        return envelope.data;
+    }
+}
+const DisableTenantGateway_DisableTenantGateway = DisableTenantGateway.createImplementation({
+    implementation: DisableTenantGraphQLGateway,
+    dependencies: [
+        MainGraphQLClient
+    ]
+});
+export { DisableTenantGateway_DisableTenantGateway as DisableTenantGateway };
+
+//# sourceMappingURL=DisableTenantGateway.js.map

package/admin/DisableTenant/DisableTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/DisableTenant/DisableTenantGateway.js","sources":["../../../src/admin/DisableTenant/DisableTenantGateway.ts"],"sourcesContent":["import { MainGraphQLClient } from \"@webiny/app/features/mainGraphQLClient/index.js\";\nimport { DisableTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\n\nconst DISABLE_TENANT = /* GraphQL */ `\n    mutation DisableTenant($tenantId: ID!) {\n        tenantManager {\n            disableTenant(tenantId: $tenantId) {\n                data\n                error {\n                    code\n                    message\n                    data\n                }\n            }\n        }\n    }\n`;\n\ntype DisableTenantResponse = {\n    tenantManager: {\n        disableTenant:\n            | {\n                  data: boolean;\n                  error: null;\n              }\n            | {\n                  data: null;\n                  error: {\n                      code: string;\n                      message: string;\n                      data: Record<string, any>;\n                  };\n              };\n    };\n};\n\nclass DisableTenantGraphQLGateway implements GatewayAbstraction.Interface {\n    constructor(private client: MainGraphQLClient.Interface) {}\n\n    async disableTenant(tenantId: string): Promise<boolean> {\n        const response = await this.client.execute<DisableTenantResponse>({\n            query: DISABLE_TENANT,\n            variables: { tenantId }\n        });\n\n        const envelope = response.tenantManager.disableTenant;\n        if (envelope.error) {\n            throw new Error(envelope.error.message);\n        }\n\n        if (!envelope.data) {\n            throw new Error(\"Unable to disable tenant\");\n        }\n\n        return envelope.data;\n    }\n}\n\nexport const DisableTenantGateway = GatewayAbstraction.createImplementation({\n    implementation: DisableTenantGraphQLGateway,\n    dependencies: [MainGraphQLClient]\n});\n"],"names":["DISABLE_TENANT","DisableTenantGraphQLGateway","client","tenantId","response","envelope","Error","DisableTenantGateway","GatewayAbstraction","MainGraphQLClient"],"mappings":";;AAGA,MAAMA,iBAA+B,CAAC;;;;;;;;;;;;;AAatC,CAAC;AAoBD,MAAMC;IACF,YAAoBC,MAAmC,CAAE;aAArCA,MAAM,GAANA;IAAsC;IAE1D,MAAM,cAAcC,QAAgB,EAAoB;QACpD,MAAMC,WAAW,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAwB;YAC9D,OAAOJ;YACP,WAAW;gBAAEG;YAAS;QAC1B;QAEA,MAAME,WAAWD,SAAS,aAAa,CAAC,aAAa;QACrD,IAAIC,SAAS,KAAK,EACd,MAAM,IAAIC,MAAMD,SAAS,KAAK,CAAC,OAAO;QAG1C,IAAI,CAACA,SAAS,IAAI,EACd,MAAM,IAAIC,MAAM;QAGpB,OAAOD,SAAS,IAAI;IACxB;AACJ;AAEO,MAAME,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBP;IAChB,cAAc;QAACQ;KAAkB;AACrC"}

package/admin/DisableTenant/DisableTenantRepository.d.ts

@@ -0,0 +1,12 @@
+import { DisableTenantRepository as RepositoryAbstraction, DisableTenantGateway } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "@webiny/app-headless-cms/features/contentEntry/abstractions.js";
+declare class DisableTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private cacheProvider;
+    constructor(gateway: DisableTenantGateway.Interface, cacheProvider: ContentEntriesCacheProvider.Interface);
+    execute(tenantId: string): Promise<void>;
+}
+export declare const DisableTenantRepository: typeof DisableTenantRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDisableTenantRepository>;
+};
+export {};

package/admin/DisableTenant/DisableTenantRepository.js

@@ -0,0 +1,33 @@
+import { DisableTenantGateway, DisableTenantRepository } from "./abstractions.js";
+import { ContentEntriesCacheProvider } from "@webiny/app-headless-cms/features/contentEntry/abstractions.js";
+import { TENANT_MODEL_ID } from "../../shared/constants.js";
+class DisableTenantRepositoryImpl {
+    constructor(gateway, cacheProvider){
+        this.gateway = gateway;
+        this.cacheProvider = cacheProvider;
+    }
+    async execute(tenantId) {
+        await this.gateway.disableTenant(tenantId);
+        const cache = this.cacheProvider.get(TENANT_MODEL_ID);
+        cache.updateItems((item)=>{
+            if (item.entryId === tenantId) return {
+                ...item,
+                values: {
+                    ...item.values,
+                    status: "disabled"
+                }
+            };
+            return item;
+        });
+    }
+}
+const DisableTenantRepository_DisableTenantRepository = DisableTenantRepository.createImplementation({
+    implementation: DisableTenantRepositoryImpl,
+    dependencies: [
+        DisableTenantGateway,
+        ContentEntriesCacheProvider
+    ]
+});
+export { DisableTenantRepository_DisableTenantRepository as DisableTenantRepository };
+
+//# sourceMappingURL=DisableTenantRepository.js.map

package/admin/DisableTenant/DisableTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/DisableTenant/DisableTenantRepository.js","sources":["../../../src/admin/DisableTenant/DisableTenantRepository.ts"],"sourcesContent":["import {\n    DisableTenantRepository as RepositoryAbstraction,\n    DisableTenantGateway\n} from \"./abstractions.js\";\nimport { ContentEntriesCacheProvider } from \"@webiny/app-headless-cms/features/contentEntry/abstractions.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\n\nclass DisableTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: DisableTenantGateway.Interface,\n        private cacheProvider: ContentEntriesCacheProvider.Interface\n    ) {}\n\n    async execute(tenantId: string): Promise<void> {\n        await this.gateway.disableTenant(tenantId);\n\n        const cache = this.cacheProvider.get(TENANT_MODEL_ID);\n        cache.updateItems(item => {\n            if (item.entryId === tenantId) {\n                return { ...item, values: { ...item.values, status: \"disabled\" } };\n            }\n            return item;\n        });\n    }\n}\n\nexport const DisableTenantRepository = RepositoryAbstraction.createImplementation({\n    implementation: DisableTenantRepositoryImpl,\n    dependencies: [DisableTenantGateway, ContentEntriesCacheProvider]\n});\n"],"names":["DisableTenantRepositoryImpl","gateway","cacheProvider","tenantId","cache","TENANT_MODEL_ID","item","DisableTenantRepository","RepositoryAbstraction","DisableTenantGateway","ContentEntriesCacheProvider"],"mappings":";;;AAOA,MAAMA;IACF,YACYC,OAAuC,EACvCC,aAAoD,CAC9D;aAFUD,OAAO,GAAPA;aACAC,aAAa,GAAbA;IACT;IAEH,MAAM,QAAQC,QAAgB,EAAiB;QAC3C,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAACA;QAEjC,MAAMC,QAAQ,IAAI,CAAC,aAAa,CAAC,GAAG,CAACC;QACrCD,MAAM,WAAW,CAACE,CAAAA;YACd,IAAIA,KAAK,OAAO,KAAKH,UACjB,OAAO;gBAAE,GAAGG,IAAI;gBAAE,QAAQ;oBAAE,GAAGA,KAAK,MAAM;oBAAE,QAAQ;gBAAW;YAAE;YAErE,OAAOA;QACX;IACJ;AACJ;AAEO,MAAMC,kDAA0BC,wBAAAA,oBAA0C,CAAC;IAC9E,gBAAgBR;IAChB,cAAc;QAACS;QAAsBC;KAA4B;AACrE"}

package/admin/DisableTenant/DisableTenantUseCase.d.ts

@@ -0,0 +1,10 @@
+import { DisableTenantUseCase as UseCaseAbstraction, DisableTenantRepository } from "./abstractions.js";
+declare class DisableTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: DisableTenantRepository.Interface);
+    execute(tenantId: string): Promise<void>;
+}
+export declare const DisableTenantUseCase: typeof DisableTenantUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDisableTenantUseCase>;
+};
+export {};

package/admin/DisableTenant/DisableTenantUseCase.js

@@ -0,0 +1,18 @@
+import { DisableTenantRepository, DisableTenantUseCase } from "./abstractions.js";
+class DisableTenantUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(tenantId) {
+        return this.repository.execute(tenantId);
+    }
+}
+const DisableTenantUseCase_DisableTenantUseCase = DisableTenantUseCase.createImplementation({
+    implementation: DisableTenantUseCaseImpl,
+    dependencies: [
+        DisableTenantRepository
+    ]
+});
+export { DisableTenantUseCase_DisableTenantUseCase as DisableTenantUseCase };
+
+//# sourceMappingURL=DisableTenantUseCase.js.map

package/admin/DisableTenant/DisableTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/DisableTenant/DisableTenantUseCase.js","sources":["../../../src/admin/DisableTenant/DisableTenantUseCase.ts"],"sourcesContent":["import {\n    DisableTenantUseCase as UseCaseAbstraction,\n    DisableTenantRepository\n} from \"./abstractions.js\";\n\nclass DisableTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: DisableTenantRepository.Interface) {}\n\n    async execute(tenantId: string): Promise<void> {\n        return this.repository.execute(tenantId);\n    }\n}\n\nexport const DisableTenantUseCase = UseCaseAbstraction.createImplementation({\n    implementation: DisableTenantUseCaseImpl,\n    dependencies: [DisableTenantRepository]\n});\n"],"names":["DisableTenantUseCaseImpl","repository","tenantId","DisableTenantUseCase","UseCaseAbstraction","DisableTenantRepository"],"mappings":";AAKA,MAAMA;IACF,YAAoBC,UAA6C,CAAE;aAA/CA,UAAU,GAAVA;IAAgD;IAEpE,MAAM,QAAQC,QAAgB,EAAiB;QAC3C,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAACA;IACnC;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAAuC,CAAC;IACxE,gBAAgBJ;IAChB,cAAc;QAACK;KAAwB;AAC3C"}

package/admin/DisableTenant/abstractions.d.ts

@@ -0,0 +1,21 @@
+export interface IDisableTenantUseCase {
+    execute(tenantId: string): Promise<void>;
+}
+export declare const DisableTenantUseCase: import("@webiny/di").Abstraction<IDisableTenantUseCase>;
+export declare namespace DisableTenantUseCase {
+    type Interface = IDisableTenantUseCase;
+}
+export interface IDisableTenantRepository {
+    execute(tenantId: string): Promise<void>;
+}
+export declare const DisableTenantRepository: import("@webiny/di").Abstraction<IDisableTenantRepository>;
+export declare namespace DisableTenantRepository {
+    type Interface = IDisableTenantRepository;
+}
+export interface IDisableTenantGateway {
+    disableTenant(tenantId: string): Promise<boolean>;
+}
+export declare const DisableTenantGateway: import("@webiny/di").Abstraction<IDisableTenantGateway>;
+export declare namespace DisableTenantGateway {
+    type Interface = IDisableTenantGateway;
+}

package/admin/DisableTenant/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/admin";
+const DisableTenantUseCase = createAbstraction("DisableTenantUseCase");
+const DisableTenantRepository = createAbstraction("DisableTenantRepository");
+const DisableTenantGateway = createAbstraction("DisableTenantGateway");
+export { DisableTenantGateway, DisableTenantRepository, DisableTenantUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/admin/DisableTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/DisableTenant/abstractions.js","sources":["../../../src/admin/DisableTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/admin\";\n\n// UseCase abstraction - only execute method\nexport interface IDisableTenantUseCase {\n    execute(tenantId: string): Promise<void>;\n}\n\nexport const DisableTenantUseCase =\n    createAbstraction<IDisableTenantUseCase>(\"DisableTenantUseCase\");\n\nexport namespace DisableTenantUseCase {\n    export type Interface = IDisableTenantUseCase;\n}\n\n// Repository abstraction - delegates to gateway\nexport interface IDisableTenantRepository {\n    execute(tenantId: string): Promise<void>;\n}\n\nexport const DisableTenantRepository =\n    createAbstraction<IDisableTenantRepository>(\"DisableTenantRepository\");\n\nexport namespace DisableTenantRepository {\n    export type Interface = IDisableTenantRepository;\n}\n\n// Gateway abstraction - GraphQL call\nexport interface IDisableTenantGateway {\n    disableTenant(tenantId: string): Promise<boolean>;\n}\n\nexport const DisableTenantGateway =\n    createAbstraction<IDisableTenantGateway>(\"DisableTenantGateway\");\n\nexport namespace DisableTenantGateway {\n    export type Interface = IDisableTenantGateway;\n}\n"],"names":["DisableTenantUseCase","createAbstraction","DisableTenantRepository","DisableTenantGateway"],"mappings":";AAOO,MAAMA,uBACTC,kBAAyC;AAWtC,MAAMC,0BACTD,kBAA4C;AAWzC,MAAME,uBACTF,kBAAyC"}