@webiny/api-core 0.0.0-unstable.0d717d18dd

package/features/tenancy/ListTenants/ListTenantsRepository.js

@@ -0,0 +1,20 @@
+import { createImplementation } from "@webiny/feature/api";
+import { ListTenantsGateway, ListTenantsRepository } from "./abstractions.js";
+class ListTenantsRepositoryImpl {
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async list(params) {
+        return await this.gateway.listTenants(params);
+    }
+}
+const ListTenantsRepository_ListTenantsRepository = createImplementation({
+    abstraction: ListTenantsRepository,
+    implementation: ListTenantsRepositoryImpl,
+    dependencies: [
+        ListTenantsGateway
+    ]
+});
+export { ListTenantsRepository_ListTenantsRepository as ListTenantsRepository };
+
+//# sourceMappingURL=ListTenantsRepository.js.map

package/features/tenancy/ListTenants/ListTenantsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/ListTenants/ListTenantsRepository.js","sources":["../../../../src/features/tenancy/ListTenants/ListTenantsRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { ListTenantsRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { ListTenantsGateway } from \"./abstractions.js\";\nimport type { ListTenantsParams } from \"~/types/tenancy.js\";\n\nclass ListTenantsRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(private gateway: ListTenantsGateway.Interface) {}\n\n    async list(params?: ListTenantsParams) {\n        return await this.gateway.listTenants(params);\n    }\n}\n\nexport const ListTenantsRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: ListTenantsRepositoryImpl,\n    dependencies: [ListTenantsGateway]\n});\n"],"names":["ListTenantsRepositoryImpl","gateway","params","ListTenantsRepository","createImplementation","RepositoryAbstraction","ListTenantsGateway"],"mappings":";;AAKA,MAAMA;IACF,YAAoBC,OAAqC,CAAE;aAAvCA,OAAO,GAAPA;IAAwC;IAE5D,MAAM,KAAKC,MAA0B,EAAE;QACnC,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAACA;IAC1C;AACJ;AAEO,MAAMC,8CAAwBC,qBAAqB;IACtD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAmB;AACtC"}

package/features/tenancy/ListTenants/ListTenantsUseCase.d.ts

@@ -0,0 +1,11 @@
+import { Result } from "@webiny/feature/api";
+import { ListTenantsUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { ListTenantsRepository } from "./abstractions.js";
+import type { ListTenantsParams } from "../../../types/tenancy.js";
+declare class ListTenantsUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: ListTenantsRepository.Interface);
+    execute(params?: ListTenantsParams): Promise<Result<import("~/types/tenancy.js").Tenant[], never>>;
+}
+export declare const ListTenantsUseCase: import("@webiny/di").Implementation<typeof ListTenantsUseCaseImpl>;
+export {};

package/features/tenancy/ListTenants/ListTenantsUseCase.js

@@ -0,0 +1,21 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { ListTenantsRepository, ListTenantsUseCase } from "./abstractions.js";
+class ListTenantsUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(params) {
+        const tenants = await this.repository.list(params);
+        return Result.ok(tenants);
+    }
+}
+const ListTenantsUseCase_ListTenantsUseCase = createImplementation({
+    abstraction: ListTenantsUseCase,
+    implementation: ListTenantsUseCaseImpl,
+    dependencies: [
+        ListTenantsRepository
+    ]
+});
+export { ListTenantsUseCase_ListTenantsUseCase as ListTenantsUseCase };
+
+//# sourceMappingURL=ListTenantsUseCase.js.map

package/features/tenancy/ListTenants/ListTenantsUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/ListTenants/ListTenantsUseCase.js","sources":["../../../../src/features/tenancy/ListTenants/ListTenantsUseCase.ts"],"sourcesContent":["import { createImplementation, Result } from \"@webiny/feature/api\";\nimport { ListTenantsUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { ListTenantsRepository } from \"./abstractions.js\";\nimport type { ListTenantsParams } from \"~/types/tenancy.js\";\n\nclass ListTenantsUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: ListTenantsRepository.Interface) {}\n\n    async execute(params?: ListTenantsParams) {\n        const tenants = await this.repository.list(params);\n\n        return Result.ok(tenants);\n    }\n}\n\nexport const ListTenantsUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: ListTenantsUseCaseImpl,\n    dependencies: [ListTenantsRepository]\n});\n"],"names":["ListTenantsUseCaseImpl","repository","params","tenants","Result","ListTenantsUseCase","createImplementation","UseCaseAbstraction","ListTenantsRepository"],"mappings":";;AAKA,MAAMA;IACF,YAAoBC,UAA2C,CAAE;aAA7CA,UAAU,GAAVA;IAA8C;IAElE,MAAM,QAAQC,MAA0B,EAAE;QACtC,MAAMC,UAAU,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAACD;QAE3C,OAAOE,OAAO,EAAE,CAACD;IACrB;AACJ;AAEO,MAAME,wCAAqBC,qBAAqB;IACnD,aAAaC;IACb,gBAAgBP;IAChB,cAAc;QAACQ;KAAsB;AACzC"}

package/features/tenancy/ListTenants/abstractions.d.ts

@@ -0,0 +1,23 @@
+import { Result } from "@webiny/feature/api";
+import type { Tenant, ListTenantsParams } from "../../../types/tenancy.js";
+export interface IListTenantsUseCase {
+    execute(params?: ListTenantsParams): Promise<Result<Tenant[]>>;
+}
+export declare const ListTenantsUseCase: import("@webiny/di").Abstraction<IListTenantsUseCase>;
+export declare namespace ListTenantsUseCase {
+    type Interface = IListTenantsUseCase;
+}
+export interface IListTenantsRepository {
+    list(params?: ListTenantsParams): Promise<Tenant[]>;
+}
+export declare const ListTenantsRepository: import("@webiny/di").Abstraction<IListTenantsRepository>;
+export declare namespace ListTenantsRepository {
+    type Interface = IListTenantsRepository;
+}
+export interface IListTenantsGateway {
+    listTenants(params?: ListTenantsParams): Promise<Tenant[]>;
+}
+export declare const ListTenantsGateway: import("@webiny/di").Abstraction<IListTenantsGateway>;
+export declare namespace ListTenantsGateway {
+    type Interface = IListTenantsGateway;
+}

package/features/tenancy/ListTenants/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/api";
+const ListTenantsUseCase = createAbstraction("ListTenantsUseCase");
+const ListTenantsRepository = createAbstraction("ListTenantsRepository");
+const ListTenantsGateway = createAbstraction("ListTenantsGateway");
+export { ListTenantsGateway, ListTenantsRepository, ListTenantsUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/tenancy/ListTenants/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/ListTenants/abstractions.js","sources":["../../../../src/features/tenancy/ListTenants/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { Tenant, ListTenantsParams } from \"~/types/tenancy.js\";\n\n// Use Case Abstraction\nexport interface IListTenantsUseCase {\n    execute(params?: ListTenantsParams): Promise<Result<Tenant[]>>;\n}\n\nexport const ListTenantsUseCase = createAbstraction<IListTenantsUseCase>(\"ListTenantsUseCase\");\n\nexport namespace ListTenantsUseCase {\n    export type Interface = IListTenantsUseCase;\n}\n\n// Repository Abstraction\nexport interface IListTenantsRepository {\n    list(params?: ListTenantsParams): Promise<Tenant[]>;\n}\n\nexport const ListTenantsRepository =\n    createAbstraction<IListTenantsRepository>(\"ListTenantsRepository\");\n\nexport namespace ListTenantsRepository {\n    export type Interface = IListTenantsRepository;\n}\n\n// Gateway Abstraction\nexport interface IListTenantsGateway {\n    listTenants(params?: ListTenantsParams): Promise<Tenant[]>;\n}\n\nexport const ListTenantsGateway = createAbstraction<IListTenantsGateway>(\"ListTenantsGateway\");\n\nexport namespace ListTenantsGateway {\n    export type Interface = IListTenantsGateway;\n}\n"],"names":["ListTenantsUseCase","createAbstraction","ListTenantsRepository","ListTenantsGateway"],"mappings":";AAQO,MAAMA,qBAAqBC,kBAAuC;AAWlE,MAAMC,wBACTD,kBAA0C;AAWvC,MAAME,qBAAqBF,kBAAuC"}

package/features/tenancy/ListTenants/feature.d.ts

@@ -0,0 +1,5 @@
+import type { Container } from "@webiny/di";
+export declare const ListTenantsFeature: {
+    name: string;
+    register(container: Container): void;
+};

package/features/tenancy/ListTenants/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListTenantsUseCase } from "./ListTenantsUseCase.js";
+import { ListTenantsRepository } from "./ListTenantsRepository.js";
+import { ListTenantsGateway } from "./ListTenantsGateway.js";
+const ListTenantsFeature = createFeature({
+    name: "ListTenants",
+    register (container) {
+        container.register(ListTenantsUseCase);
+        container.register(ListTenantsRepository).inSingletonScope();
+        container.register(ListTenantsGateway).inSingletonScope();
+    }
+});
+export { ListTenantsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/tenancy/ListTenants/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/ListTenants/feature.js","sources":["../../../../src/features/tenancy/ListTenants/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { ListTenantsUseCase } from \"./ListTenantsUseCase.js\";\nimport { ListTenantsRepository } from \"./ListTenantsRepository.js\";\nimport { ListTenantsGateway } from \"./ListTenantsGateway.js\";\n\nexport const ListTenantsFeature = createFeature({\n    name: \"ListTenants\",\n    register(container: Container) {\n        container.register(ListTenantsUseCase);\n        container.register(ListTenantsRepository).inSingletonScope();\n        container.register(ListTenantsGateway).inSingletonScope();\n    }\n});\n"],"names":["ListTenantsFeature","createFeature","container","ListTenantsUseCase","ListTenantsRepository","ListTenantsGateway"],"mappings":";;;;AAMO,MAAMA,qBAAqBC,cAAc;IAC5C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,uBAAuB,gBAAgB;QAC1DF,UAAU,QAAQ,CAACG,oBAAoB,gBAAgB;IAC3D;AACJ"}

package/features/tenancy/ListTenants/index.d.ts

@@ -0,0 +1,2 @@
+export { ListTenantsFeature } from "./feature.js";
+export { ListTenantsUseCase, ListTenantsRepository, ListTenantsGateway } from "./abstractions.js";

package/features/tenancy/ListTenants/index.js

@@ -0,0 +1,2 @@
+export { ListTenantsFeature } from "./feature.js";
+export { ListTenantsGateway, ListTenantsRepository, ListTenantsUseCase } from "./abstractions.js";

package/features/tenancy/TenancyFeature.d.ts

@@ -0,0 +1,5 @@
+import type { TenancyStorageOperations as ITenancyStorageOperations } from "../../types/tenancy.js";
+export declare const TenancyFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container, context: ITenancyStorageOperations): void;
+};

package/features/tenancy/TenancyFeature.js

@@ -0,0 +1,34 @@
+import { createFeature } from "@webiny/feature/api";
+import { TenantCache } from "./shared/abstractions.js";
+import { TenantCache as TenantCache_js_TenantCache } from "./shared/TenantCache.js";
+import { TenancyStorageOperations } from "./shared/storageOperations.js";
+import { GetRootTenantFeature } from "./GetRootTenant/feature.js";
+import { ListTenantsFeature } from "./ListTenants/feature.js";
+import { CreateTenantFeature } from "./CreateTenant/feature.js";
+import { UpdateTenantFeature } from "./UpdateTenant/feature.js";
+import { DeleteTenantFeature } from "./DeleteTenant/feature.js";
+import { GetTenantByIdFeature } from "./GetTenantById/feature.js";
+import { TenantContextFeature } from "./TenantContext/feature.js";
+import { InstallTenantFeature } from "./InstallTenant/index.js";
+const TenancyFeature = createFeature({
+    name: "TenancyFeature",
+    register: (container, storageOperations)=>{
+        container.registerInstance(TenancyStorageOperations, storageOperations);
+        container.registerInstance(TenantCache, new TenantCache_js_TenantCache(async (ids)=>{
+            if (0 === ids.length) return [];
+            const tenants = await storageOperations.getTenantsByIds(ids);
+            return ids.map((_, index)=>tenants[index]);
+        }));
+        CreateTenantFeature.register(container);
+        DeleteTenantFeature.register(container);
+        GetRootTenantFeature.register(container);
+        GetTenantByIdFeature.register(container);
+        ListTenantsFeature.register(container);
+        UpdateTenantFeature.register(container);
+        TenantContextFeature.register(container);
+        InstallTenantFeature.register(container);
+    }
+});
+export { TenancyFeature };
+
+//# sourceMappingURL=TenancyFeature.js.map

package/features/tenancy/TenancyFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/TenancyFeature.js","sources":["../../../src/features/tenancy/TenancyFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { TenancyStorageOperations as ITenancyStorageOperations } from \"~/types/tenancy.js\";\nimport { TenantCache } from \"./shared/abstractions.js\";\nimport { TenantCache as TenantCacheImpl } from \"./shared/TenantCache.js\";\nimport { TenancyStorageOperations } from \"./shared/storageOperations.js\";\nimport { GetRootTenantFeature } from \"./GetRootTenant/feature.js\";\nimport { ListTenantsFeature } from \"./ListTenants/feature.js\";\nimport { CreateTenantFeature } from \"./CreateTenant/feature.js\";\nimport { UpdateTenantFeature } from \"./UpdateTenant/feature.js\";\nimport { DeleteTenantFeature } from \"./DeleteTenant/feature.js\";\nimport { GetTenantByIdFeature } from \"./GetTenantById/feature.js\";\nimport { TenantContextFeature } from \"./TenantContext/feature.js\";\nimport { InstallTenantFeature } from \"./InstallTenant/index.js\";\n\nexport const TenancyFeature = createFeature<ITenancyStorageOperations>({\n    name: \"TenancyFeature\",\n    register: (container, storageOperations) => {\n        // Register storage operations abstraction (singleton)\n        container.registerInstance(TenancyStorageOperations, storageOperations);\n\n        // Register shared cache (singleton) - batch loader provided here\n        container.registerInstance(\n            TenantCache,\n            new TenantCacheImpl(async (ids: readonly string[]) => {\n                if (ids.length === 0) {\n                    return [];\n                }\n                const tenants = await storageOperations.getTenantsByIds(ids);\n                return ids.map((_, index) => tenants[index]);\n            })\n        );\n\n        // Register all features - they will auto-wire their dependencies from the container\n        CreateTenantFeature.register(container);\n        DeleteTenantFeature.register(container);\n        GetRootTenantFeature.register(container);\n        GetTenantByIdFeature.register(container);\n        ListTenantsFeature.register(container);\n        UpdateTenantFeature.register(container);\n        TenantContextFeature.register(container);\n        InstallTenantFeature.register(container);\n    }\n});\n"],"names":["TenancyFeature","createFeature","container","storageOperations","TenancyStorageOperations","TenantCache","TenantCacheImpl","ids","tenants","_","index","CreateTenantFeature","DeleteTenantFeature","GetRootTenantFeature","GetTenantByIdFeature","ListTenantsFeature","UpdateTenantFeature","TenantContextFeature","InstallTenantFeature"],"mappings":";;;;;;;;;;;;AAcO,MAAMA,iBAAiBC,cAAyC;IACnE,MAAM;IACN,UAAU,CAACC,WAAWC;QAElBD,UAAU,gBAAgB,CAACE,0BAA0BD;QAGrDD,UAAU,gBAAgB,CACtBG,aACA,IAAIC,2BAAgB,OAAOC;YACvB,IAAIA,AAAe,MAAfA,IAAI,MAAM,EACV,OAAO,EAAE;YAEb,MAAMC,UAAU,MAAML,kBAAkB,eAAe,CAACI;YACxD,OAAOA,IAAI,GAAG,CAAC,CAACE,GAAGC,QAAUF,OAAO,CAACE,MAAM;QAC/C;QAIJC,oBAAoB,QAAQ,CAACT;QAC7BU,oBAAoB,QAAQ,CAACV;QAC7BW,qBAAqB,QAAQ,CAACX;QAC9BY,qBAAqB,QAAQ,CAACZ;QAC9Ba,mBAAmB,QAAQ,CAACb;QAC5Bc,oBAAoB,QAAQ,CAACd;QAC7Be,qBAAqB,QAAQ,CAACf;QAC9BgB,qBAAqB,QAAQ,CAAChB;IAClC;AACJ"}

package/features/tenancy/TenantContext/TenantContext.d.ts

@@ -0,0 +1,15 @@
+import { TenantContext as Abstraction } from "./abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+import { GetRootTenantUseCase } from "../../../features/tenancy/GetRootTenant/index.js";
+declare class TenantContextImpl implements Abstraction.Interface {
+    private getRootTenant;
+    private currentTenant;
+    constructor(getRootTenant: GetRootTenantUseCase.Interface);
+    getTenant(): Tenant;
+    setTenant(tenant: Tenant): void;
+    withRootTenant<T>(cb: () => T): Promise<T>;
+    withEachTenant<TReturn>(tenants: Tenant[], cb: (tenant: Tenant) => Promise<TReturn>): Promise<TReturn[]>;
+    withTenant<TReturn>(tenant: Tenant, cb: (tenant: Tenant) => Promise<TReturn>): Promise<TReturn>;
+}
+export declare const TenantContext: import("@webiny/di").Implementation<typeof TenantContextImpl>;
+export {};

package/features/tenancy/TenantContext/TenantContext.js

@@ -0,0 +1,59 @@
+import { createImplementation } from "@webiny/feature/api";
+import { TenantContext } from "./abstractions.js";
+import { GetRootTenantUseCase } from "../GetRootTenant/index.js";
+import { TenantIsDisabledError } from "./errors.js";
+class TenantContextImpl {
+    constructor(getRootTenant){
+        this.getRootTenant = getRootTenant;
+        this.currentTenant = null;
+    }
+    getTenant() {
+        return this.currentTenant;
+    }
+    setTenant(tenant) {
+        if (tenant.isInstalled && "disabled" === tenant.status) throw new TenantIsDisabledError();
+        this.currentTenant = tenant;
+    }
+    async withRootTenant(cb) {
+        const initialTenant = this.getTenant();
+        const rootTenant = await this.getRootTenant.execute();
+        if (!rootTenant.isOk()) return rootTenant.error;
+        const tenant = rootTenant.value;
+        this.setTenant(tenant);
+        try {
+            return await cb();
+        } finally{
+            this.setTenant(initialTenant);
+        }
+    }
+    async withEachTenant(tenants, cb) {
+        const initialTenant = this.getTenant();
+        const results = [];
+        for (const tenant of tenants){
+            this.setTenant(tenant);
+            try {
+                results.push(await cb(tenant));
+            } finally{
+                this.setTenant(initialTenant);
+            }
+        }
+        return results;
+    }
+    async withTenant(tenant, cb) {
+        const initialTenant = this.getTenant();
+        this.setTenant(tenant);
+        const result = await cb(tenant);
+        this.setTenant(initialTenant);
+        return result;
+    }
+}
+const TenantContext_TenantContext = createImplementation({
+    abstraction: TenantContext,
+    implementation: TenantContextImpl,
+    dependencies: [
+        GetRootTenantUseCase
+    ]
+});
+export { TenantContext_TenantContext as TenantContext };
+
+//# sourceMappingURL=TenantContext.js.map

package/features/tenancy/TenantContext/TenantContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/TenantContext/TenantContext.js","sources":["../../../../src/features/tenancy/TenantContext/TenantContext.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { TenantContext as Abstraction } from \"./abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { GetRootTenantUseCase } from \"~/features/tenancy/GetRootTenant/index.js\";\nimport { TenantIsDisabledError } from \"./errors.js\";\n\nclass TenantContextImpl implements Abstraction.Interface {\n    private currentTenant: Tenant | null = null;\n\n    constructor(private getRootTenant: GetRootTenantUseCase.Interface) {}\n\n    getTenant(): Tenant {\n        return this.currentTenant!;\n    }\n\n    setTenant(tenant: Tenant): void {\n        if (tenant.isInstalled && tenant.status === \"disabled\") {\n            throw new TenantIsDisabledError();\n        }\n        this.currentTenant = tenant;\n    }\n\n    async withRootTenant<T>(cb: () => T): Promise<T> {\n        const initialTenant = this.getTenant();\n        const rootTenant = await this.getRootTenant.execute();\n        if (!rootTenant.isOk()) {\n            return rootTenant.error as T;\n        }\n\n        const tenant = rootTenant.value;\n\n        this.setTenant(tenant);\n        try {\n            return await cb();\n        } finally {\n            // Make sure that, whatever happens in the callback, the tenant is set back to the initial one.\n            this.setTenant(initialTenant);\n        }\n    }\n\n    async withEachTenant<TReturn>(\n        tenants: Tenant[],\n        cb: (tenant: Tenant) => Promise<TReturn>\n    ): Promise<TReturn[]> {\n        const initialTenant = this.getTenant();\n        const results = [];\n        for (const tenant of tenants) {\n            this.setTenant(tenant);\n            try {\n                results.push(await cb(tenant));\n            } finally {\n                this.setTenant(initialTenant);\n            }\n        }\n        return results;\n    }\n\n    async withTenant<TReturn>(\n        tenant: Tenant,\n        cb: (tenant: Tenant) => Promise<TReturn>\n    ): Promise<TReturn> {\n        const initialTenant = this.getTenant();\n        this.setTenant(tenant);\n        const result = await cb(tenant);\n        this.setTenant(initialTenant);\n        return result;\n    }\n}\n\nexport const TenantContext = createImplementation({\n    abstraction: Abstraction,\n    implementation: TenantContextImpl,\n    dependencies: [GetRootTenantUseCase]\n});\n"],"names":["TenantContextImpl","getRootTenant","tenant","TenantIsDisabledError","cb","initialTenant","rootTenant","tenants","results","result","TenantContext","createImplementation","Abstraction","GetRootTenantUseCase"],"mappings":";;;;AAMA,MAAMA;IAGF,YAAoBC,aAA6C,CAAE;aAA/CA,aAAa,GAAbA;aAFZ,aAAa,GAAkB;IAE6B;IAEpE,YAAoB;QAChB,OAAO,IAAI,CAAC,aAAa;IAC7B;IAEA,UAAUC,MAAc,EAAQ;QAC5B,IAAIA,OAAO,WAAW,IAAIA,AAAkB,eAAlBA,OAAO,MAAM,EACnC,MAAM,IAAIC;QAEd,IAAI,CAAC,aAAa,GAAGD;IACzB;IAEA,MAAM,eAAkBE,EAAW,EAAc;QAC7C,MAAMC,gBAAgB,IAAI,CAAC,SAAS;QACpC,MAAMC,aAAa,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO;QACnD,IAAI,CAACA,WAAW,IAAI,IAChB,OAAOA,WAAW,KAAK;QAG3B,MAAMJ,SAASI,WAAW,KAAK;QAE/B,IAAI,CAAC,SAAS,CAACJ;QACf,IAAI;YACA,OAAO,MAAME;QACjB,SAAU;YAEN,IAAI,CAAC,SAAS,CAACC;QACnB;IACJ;IAEA,MAAM,eACFE,OAAiB,EACjBH,EAAwC,EACtB;QAClB,MAAMC,gBAAgB,IAAI,CAAC,SAAS;QACpC,MAAMG,UAAU,EAAE;QAClB,KAAK,MAAMN,UAAUK,QAAS;YAC1B,IAAI,CAAC,SAAS,CAACL;YACf,IAAI;gBACAM,QAAQ,IAAI,CAAC,MAAMJ,GAAGF;YAC1B,SAAU;gBACN,IAAI,CAAC,SAAS,CAACG;YACnB;QACJ;QACA,OAAOG;IACX;IAEA,MAAM,WACFN,MAAc,EACdE,EAAwC,EACxB;QAChB,MAAMC,gBAAgB,IAAI,CAAC,SAAS;QACpC,IAAI,CAAC,SAAS,CAACH;QACf,MAAMO,SAAS,MAAML,GAAGF;QACxB,IAAI,CAAC,SAAS,CAACG;QACf,OAAOI;IACX;AACJ;AAEO,MAAMC,8BAAgBC,qBAAqB;IAC9C,aAAaC;IACb,gBAAgBZ;IAChB,cAAc;QAACa;KAAqB;AACxC"}

package/features/tenancy/TenantContext/abstractions.d.ts

@@ -0,0 +1,13 @@
+import type { Tenant } from "../../../types/tenancy.js";
+export interface ITenantContext {
+    setTenant(tenant: Tenant): void;
+    getTenant(): Tenant;
+    withRootTenant<T>(cb: () => T): Promise<T>;
+    withEachTenant<TReturn>(tenants: Tenant[], cb: (tenant: Tenant) => Promise<TReturn>): Promise<TReturn[]>;
+    withTenant<TReturn>(tenant: Tenant, cb: (tenant: Tenant) => Promise<TReturn>): Promise<TReturn>;
+}
+/** Provides access to the current tenant and tenant-scoped execution. */
+export declare const TenantContext: import("@webiny/di").Abstraction<ITenantContext>;
+export declare namespace TenantContext {
+    type Interface = ITenantContext;
+}

package/features/tenancy/TenantContext/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const TenantContext = createAbstraction("TenantContext");
+export { TenantContext };
+
+//# sourceMappingURL=abstractions.js.map

package/features/tenancy/TenantContext/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/TenantContext/abstractions.js","sources":["../../../../src/features/tenancy/TenantContext/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nexport interface ITenantContext {\n    setTenant(tenant: Tenant): void;\n    getTenant(): Tenant;\n    withRootTenant<T>(cb: () => T): Promise<T>;\n    withEachTenant<TReturn>(\n        tenants: Tenant[],\n        cb: (tenant: Tenant) => Promise<TReturn>\n    ): Promise<TReturn[]>;\n    withTenant<TReturn>(tenant: Tenant, cb: (tenant: Tenant) => Promise<TReturn>): Promise<TReturn>;\n}\n\n/** Provides access to the current tenant and tenant-scoped execution. */\nexport const TenantContext = createAbstraction<ITenantContext>(\"TenantContext\");\n\nexport namespace TenantContext {\n    export type Interface = ITenantContext;\n}\n"],"names":["TenantContext","createAbstraction"],"mappings":";AAeO,MAAMA,gBAAgBC,kBAAkC"}

package/features/tenancy/TenantContext/errors.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class TenantIsDisabledError extends BaseError {
+    readonly code: "Tenancy/TenantDisabled";
+    constructor();
+}

package/features/tenancy/TenantContext/errors.js

@@ -0,0 +1,11 @@
+import { BaseError } from "@webiny/feature/api";
+class TenantIsDisabledError extends BaseError {
+    constructor(){
+        super({
+            message: "Tenant is disabled!"
+        }), this.code = "Tenancy/TenantDisabled";
+    }
+}
+export { TenantIsDisabledError };
+
+//# sourceMappingURL=errors.js.map

package/features/tenancy/TenantContext/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/TenantContext/errors.js","sources":["../../../../src/features/tenancy/TenantContext/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class TenantIsDisabledError extends BaseError {\n    override readonly code = \"Tenancy/TenantDisabled\" as const;\n\n    constructor() {\n        super({ message: \"Tenant is disabled!\" });\n    }\n}\n"],"names":["TenantIsDisabledError","BaseError"],"mappings":";AAEO,MAAMA,8BAA8BC;IAGvC,aAAc;QACV,KAAK,CAAC;YAAE,SAAS;QAAsB,SAHzB,IAAI,GAAG;IAIzB;AACJ"}

package/features/tenancy/TenantContext/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const TenantContextFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/tenancy/TenantContext/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { TenantContext } from "./TenantContext.js";
+const TenantContextFeature = createFeature({
+    name: "TenantContextFeature",
+    register (container) {
+        container.register(TenantContext).inSingletonScope();
+    }
+});
+export { TenantContextFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/tenancy/TenantContext/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/TenantContext/feature.js","sources":["../../../../src/features/tenancy/TenantContext/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TenantContext } from \"./TenantContext.js\";\n\nexport const TenantContextFeature = createFeature({\n    name: \"TenantContextFeature\",\n    register(container) {\n        container.register(TenantContext).inSingletonScope();\n    }\n});\n"],"names":["TenantContextFeature","createFeature","container","TenantContext"],"mappings":";;AAGO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,eAAe,gBAAgB;IACtD;AACJ"}

package/features/tenancy/TenantContext/index.d.ts

@@ -0,0 +1 @@
+export { TenantContext } from "./abstractions.js";

package/features/tenancy/TenantContext/index.js

@@ -0,0 +1 @@
+export { TenantContext } from "./abstractions.js";

package/features/tenancy/UpdateTenant/UpdateTenantGateway.d.ts

@@ -0,0 +1,10 @@
+import { UpdateTenantGateway as GatewayAbstraction } from "./abstractions.js";
+import { type Tenant } from "../../../types/tenancy.js";
+import { TenancyStorageOperations } from "../../../features/tenancy/shared/storageOperations.js";
+declare class UpdateTenantGatewayImpl implements GatewayAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: TenancyStorageOperations.Interface);
+    updateTenant(data: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantGateway: import("@webiny/di").Implementation<typeof UpdateTenantGatewayImpl>;
+export {};

package/features/tenancy/UpdateTenant/UpdateTenantGateway.js

@@ -0,0 +1,21 @@
+import { createImplementation } from "@webiny/feature/api";
+import { UpdateTenantGateway } from "./abstractions.js";
+import { TenancyStorageOperations } from "../shared/storageOperations.js";
+class UpdateTenantGatewayImpl {
+    constructor(storageOperations){
+        this.storageOperations = storageOperations;
+    }
+    async updateTenant(data) {
+        return await this.storageOperations.updateTenant(data);
+    }
+}
+const UpdateTenantGateway_UpdateTenantGateway = createImplementation({
+    abstraction: UpdateTenantGateway,
+    implementation: UpdateTenantGatewayImpl,
+    dependencies: [
+        TenancyStorageOperations
+    ]
+});
+export { UpdateTenantGateway_UpdateTenantGateway as UpdateTenantGateway };
+
+//# sourceMappingURL=UpdateTenantGateway.js.map

package/features/tenancy/UpdateTenant/UpdateTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/UpdateTenant/UpdateTenantGateway.js","sources":["../../../../src/features/tenancy/UpdateTenant/UpdateTenantGateway.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport { type Tenant } from \"~/types/tenancy.js\";\nimport { TenancyStorageOperations } from \"~/features/tenancy/shared/storageOperations.js\";\n\nclass UpdateTenantGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private storageOperations: TenancyStorageOperations.Interface) {}\n\n    async updateTenant(data: Tenant) {\n        return await this.storageOperations.updateTenant(data);\n    }\n}\n\nexport const UpdateTenantGateway = createImplementation({\n    abstraction: GatewayAbstraction,\n    implementation: UpdateTenantGatewayImpl,\n    dependencies: [TenancyStorageOperations]\n});\n"],"names":["UpdateTenantGatewayImpl","storageOperations","data","UpdateTenantGateway","createImplementation","GatewayAbstraction","TenancyStorageOperations"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,iBAAqD,CAAE;aAAvDA,iBAAiB,GAAjBA;IAAwD;IAE5E,MAAM,aAAaC,IAAY,EAAE;QAC7B,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,YAAY,CAACA;IACrD;AACJ;AAEO,MAAMC,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAyB;AAC5C"}

package/features/tenancy/UpdateTenant/UpdateTenantRepository.d.ts

@@ -0,0 +1,12 @@
+import { UpdateTenantRepository as RepositoryAbstraction } from "./abstractions.js";
+import { UpdateTenantGateway } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+declare class UpdateTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private cache;
+    constructor(gateway: UpdateTenantGateway.Interface, cache: TenantCache.Interface);
+    update(tenant: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantRepository: import("@webiny/di").Implementation<typeof UpdateTenantRepositoryImpl>;
+export {};

package/features/tenancy/UpdateTenant/UpdateTenantRepository.js

@@ -0,0 +1,26 @@
+import { createImplementation } from "@webiny/feature/api";
+import { UpdateTenantGateway, UpdateTenantRepository } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+class UpdateTenantRepositoryImpl {
+    constructor(gateway, cache){
+        this.gateway = gateway;
+        this.cache = cache;
+    }
+    async update(tenant) {
+        const updated = await this.gateway.updateTenant(tenant);
+        this.cache.clear(updated.id);
+        this.cache.prime(updated.id, updated);
+        return updated;
+    }
+}
+const UpdateTenantRepository_UpdateTenantRepository = createImplementation({
+    abstraction: UpdateTenantRepository,
+    implementation: UpdateTenantRepositoryImpl,
+    dependencies: [
+        UpdateTenantGateway,
+        TenantCache
+    ]
+});
+export { UpdateTenantRepository_UpdateTenantRepository as UpdateTenantRepository };
+
+//# sourceMappingURL=UpdateTenantRepository.js.map

package/features/tenancy/UpdateTenant/UpdateTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/UpdateTenant/UpdateTenantRepository.js","sources":["../../../../src/features/tenancy/UpdateTenant/UpdateTenantRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateTenantRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { UpdateTenantGateway } from \"./abstractions.js\";\nimport { TenantCache } from \"../shared/abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nclass UpdateTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: UpdateTenantGateway.Interface,\n        private cache: TenantCache.Interface\n    ) {}\n\n    async update(tenant: Tenant) {\n        const updated = await this.gateway.updateTenant(tenant);\n        this.cache.clear(updated.id);\n        this.cache.prime(updated.id, updated);\n        return updated;\n    }\n}\n\nexport const UpdateTenantRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: UpdateTenantRepositoryImpl,\n    dependencies: [UpdateTenantGateway, TenantCache]\n});\n"],"names":["UpdateTenantRepositoryImpl","gateway","cache","tenant","updated","UpdateTenantRepository","createImplementation","RepositoryAbstraction","UpdateTenantGateway","TenantCache"],"mappings":";;;AAMA,MAAMA;IACF,YACYC,OAAsC,EACtCC,KAA4B,CACtC;aAFUD,OAAO,GAAPA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,OAAOC,MAAc,EAAE;QACzB,MAAMC,UAAU,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAACD;QAChD,IAAI,CAAC,KAAK,CAAC,KAAK,CAACC,QAAQ,EAAE;QAC3B,IAAI,CAAC,KAAK,CAAC,KAAK,CAACA,QAAQ,EAAE,EAAEA;QAC7B,OAAOA;IACX;AACJ;AAEO,MAAMC,gDAAyBC,qBAAqB;IACvD,aAAaC;IACb,gBAAgBP;IAChB,cAAc;QAACQ;QAAqBC;KAAY;AACpD"}

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.d.ts

@@ -0,0 +1,17 @@
+import { EventPublisher } from "../../../features/eventPublisher/index.js";
+import { Result } from "@webiny/feature/api";
+import { UpdateTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { UpdateTenantRepository } from "./abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+import { GetTenantByIdUseCase } from "../../../features/tenancy/GetTenantById/index.js";
+declare class UpdateTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getTenantById;
+    private eventPublisher;
+    private repository;
+    constructor(getTenantById: GetTenantByIdUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: UpdateTenantRepository.Interface);
+    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, never> | ({
+        _error: import("../GetTenantById/abstractions.js").GetTenantByIdError;
+    } & Result<Tenant, import("../GetTenantById/abstractions.js").GetTenantByIdError>)>;
+}
+export declare const UpdateTenantUseCase: import("@webiny/di").Implementation<typeof UpdateTenantUseCaseImpl>;
+export {};

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.js

@@ -0,0 +1,45 @@
+import { EventPublisher } from "../../eventPublisher/index.js";
+import { Result, createImplementation } from "@webiny/feature/api";
+import { UpdateTenantRepository, UpdateTenantUseCase } from "./abstractions.js";
+import { TenantAfterUpdateEvent, TenantBeforeUpdateEvent } from "./events.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/index.js";
+class UpdateTenantUseCaseImpl {
+    constructor(getTenantById, eventPublisher, repository){
+        this.getTenantById = getTenantById;
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+    }
+    async execute(id, data) {
+        const result = await this.getTenantById.execute(id);
+        if (result.isFail()) return result;
+        const tenant = result.value;
+        const updateData = {
+            ...data,
+            savedOn: new Date().toISOString()
+        };
+        await this.eventPublisher.publish(new TenantBeforeUpdateEvent({
+            tenant,
+            inputData: data,
+            updateData
+        }));
+        Object.assign(tenant, updateData);
+        const updatedTenant = await this.repository.update(tenant);
+        await this.eventPublisher.publish(new TenantAfterUpdateEvent({
+            tenant: updatedTenant,
+            inputData: data
+        }));
+        return Result.ok(updatedTenant);
+    }
+}
+const UpdateTenantUseCase_UpdateTenantUseCase = createImplementation({
+    abstraction: UpdateTenantUseCase,
+    implementation: UpdateTenantUseCaseImpl,
+    dependencies: [
+        GetTenantByIdUseCase,
+        EventPublisher,
+        UpdateTenantRepository
+    ]
+});
+export { UpdateTenantUseCase_UpdateTenantUseCase as UpdateTenantUseCase };
+
+//# sourceMappingURL=UpdateTenantUseCase.js.map

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/UpdateTenant/UpdateTenantUseCase.js","sources":["../../../../src/features/tenancy/UpdateTenant/UpdateTenantUseCase.ts"],"sourcesContent":["import { EventPublisher } from \"~/features/eventPublisher/index.js\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { UpdateTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UpdateTenantRepository } from \"./abstractions.js\";\nimport { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from \"./events.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { GetTenantByIdUseCase } from \"~/features/tenancy/GetTenantById/index.js\";\n\nclass UpdateTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getTenantById: GetTenantByIdUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: UpdateTenantRepository.Interface\n    ) {}\n\n    async execute(id: string, data: Partial<Tenant>) {\n        const result = await this.getTenantById.execute(id);\n\n        if (result.isFail()) {\n            return result;\n        }\n        const tenant = result.value;\n\n        const updateData = { ...data, savedOn: new Date().toISOString() };\n\n        await this.eventPublisher.publish(\n            new TenantBeforeUpdateEvent({ tenant, inputData: data, updateData })\n        );\n\n        Object.assign(tenant, updateData);\n        const updatedTenant = await this.repository.update(tenant);\n\n        await this.eventPublisher.publish(\n            new TenantAfterUpdateEvent({ tenant: updatedTenant, inputData: data })\n        );\n\n        return Result.ok(updatedTenant);\n    }\n}\n\nexport const UpdateTenantUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: UpdateTenantUseCaseImpl,\n    dependencies: [GetTenantByIdUseCase, EventPublisher, UpdateTenantRepository]\n});\n"],"names":["UpdateTenantUseCaseImpl","getTenantById","eventPublisher","repository","id","data","result","tenant","updateData","Date","TenantBeforeUpdateEvent","Object","updatedTenant","TenantAfterUpdateEvent","Result","UpdateTenantUseCase","createImplementation","UseCaseAbstraction","GetTenantByIdUseCase","EventPublisher","UpdateTenantRepository"],"mappings":";;;;;AASA,MAAMA;IACF,YACYC,aAA6C,EAC7CC,cAAwC,EACxCC,UAA4C,CACtD;aAHUF,aAAa,GAAbA;aACAC,cAAc,GAAdA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAEC,IAAqB,EAAE;QAC7C,MAAMC,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAACF;QAEhD,IAAIE,OAAO,MAAM,IACb,OAAOA;QAEX,MAAMC,SAASD,OAAO,KAAK;QAE3B,MAAME,aAAa;YAAE,GAAGH,IAAI;YAAE,SAAS,IAAII,OAAO,WAAW;QAAG;QAEhE,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,wBAAwB;YAAEH;YAAQ,WAAWF;YAAMG;QAAW;QAGtEG,OAAO,MAAM,CAACJ,QAAQC;QACtB,MAAMI,gBAAgB,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACL;QAEnD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIM,uBAAuB;YAAE,QAAQD;YAAe,WAAWP;QAAK;QAGxE,OAAOS,OAAO,EAAE,CAACF;IACrB;AACJ;AAEO,MAAMG,0CAAsBC,qBAAqB;IACpD,aAAaC;IACb,gBAAgBjB;IAChB,cAAc;QAACkB;QAAsBC;QAAgBC;KAAuB;AAChF"}

package/features/tenancy/UpdateTenant/abstractions.d.ts

@@ -0,0 +1,46 @@
+import { type Result } from "@webiny/feature/api";
+import type { IEventHandler, DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+import type { TenantBeforeUpdatePayload, TenantAfterUpdatePayload } from "./events.js";
+export type UpdateTenantError = {
+    type: "NOT_FOUND";
+} | {
+    type: "UNKNOWN";
+    cause: Error;
+};
+export interface IUpdateTenantUseCase {
+    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, UpdateTenantError>>;
+}
+/** Update an existing tenant. */
+export declare const UpdateTenantUseCase: import("@webiny/di").Abstraction<IUpdateTenantUseCase>;
+export declare namespace UpdateTenantUseCase {
+    type Interface = IUpdateTenantUseCase;
+}
+export interface IUpdateTenantRepository {
+    update(tenant: Tenant): Promise<Tenant>;
+}
+/** Persist tenant updates. */
+export declare const UpdateTenantRepository: import("@webiny/di").Abstraction<IUpdateTenantRepository>;
+export declare namespace UpdateTenantRepository {
+    type Interface = IUpdateTenantRepository;
+}
+export interface IUpdateTenantGateway {
+    updateTenant(data: Tenant): Promise<Tenant>;
+}
+/** Storage gateway for tenant updates. */
+export declare const UpdateTenantGateway: import("@webiny/di").Abstraction<IUpdateTenantGateway>;
+export declare namespace UpdateTenantGateway {
+    type Interface = IUpdateTenantGateway;
+}
+/** Hook into tenant lifecycle before a tenant is updated. */
+export declare const TenantBeforeUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>>;
+export declare namespace TenantBeforeUpdateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>;
+    type Event = DomainEvent<TenantBeforeUpdatePayload>;
+}
+/** Hook into tenant lifecycle after a tenant is updated. */
+export declare const TenantAfterUpdateEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantAfterUpdatePayload>>>;
+export declare namespace TenantAfterUpdateEventHandler {
+    type Interface = IEventHandler<DomainEvent<TenantAfterUpdatePayload>>;
+    type Event = DomainEvent<TenantAfterUpdatePayload>;
+}

package/features/tenancy/UpdateTenant/abstractions.js

@@ -0,0 +1,9 @@
+import { createAbstraction } from "@webiny/feature/api";
+const UpdateTenantUseCase = createAbstraction("UpdateTenantUseCase");
+const UpdateTenantRepository = createAbstraction("UpdateTenantRepository");
+const UpdateTenantGateway = createAbstraction("UpdateTenantGateway");
+const TenantBeforeUpdateEventHandler = createAbstraction("TenantBeforeUpdateEventHandler");
+const TenantAfterUpdateEventHandler = createAbstraction("TenantAfterUpdateEventHandler");
+export { TenantAfterUpdateEventHandler, TenantBeforeUpdateEventHandler, UpdateTenantGateway, UpdateTenantRepository, UpdateTenantUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/features/tenancy/UpdateTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/UpdateTenant/abstractions.js","sources":["../../../../src/features/tenancy/UpdateTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { IEventHandler, DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport type { TenantBeforeUpdatePayload, TenantAfterUpdatePayload } from \"./events.js\";\n\nexport type UpdateTenantError = { type: \"NOT_FOUND\" } | { type: \"UNKNOWN\"; cause: Error };\n\nexport interface IUpdateTenantUseCase {\n    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, UpdateTenantError>>;\n}\n\n/** Update an existing tenant. */\nexport const UpdateTenantUseCase = createAbstraction<IUpdateTenantUseCase>(\"UpdateTenantUseCase\");\n\nexport namespace UpdateTenantUseCase {\n    export type Interface = IUpdateTenantUseCase;\n}\n\nexport interface IUpdateTenantRepository {\n    update(tenant: Tenant): Promise<Tenant>;\n}\n\n/** Persist tenant updates. */\nexport const UpdateTenantRepository =\n    createAbstraction<IUpdateTenantRepository>(\"UpdateTenantRepository\");\n\nexport namespace UpdateTenantRepository {\n    export type Interface = IUpdateTenantRepository;\n}\n\nexport interface IUpdateTenantGateway {\n    updateTenant(data: Tenant): Promise<Tenant>;\n}\n\n/** Storage gateway for tenant updates. */\nexport const UpdateTenantGateway = createAbstraction<IUpdateTenantGateway>(\"UpdateTenantGateway\");\n\nexport namespace UpdateTenantGateway {\n    export type Interface = IUpdateTenantGateway;\n}\n\n/** Hook into tenant lifecycle before a tenant is updated. */\nexport const TenantBeforeUpdateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>\n>(\"TenantBeforeUpdateEventHandler\");\n\nexport namespace TenantBeforeUpdateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>;\n    export type Event = DomainEvent<TenantBeforeUpdatePayload>;\n}\n\n/** Hook into tenant lifecycle after a tenant is updated. */\nexport const TenantAfterUpdateEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantAfterUpdatePayload>>\n>(\"TenantAfterUpdateEventHandler\");\n\nexport namespace TenantAfterUpdateEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantAfterUpdatePayload>>;\n    export type Event = DomainEvent<TenantAfterUpdatePayload>;\n}\n"],"names":["UpdateTenantUseCase","createAbstraction","UpdateTenantRepository","UpdateTenantGateway","TenantBeforeUpdateEventHandler","TenantAfterUpdateEventHandler"],"mappings":";AAYO,MAAMA,sBAAsBC,kBAAwC;AAWpE,MAAMC,yBACTD,kBAA2C;AAWxC,MAAME,sBAAsBF,kBAAwC;AAOpE,MAAMG,iCAAiCH,kBAE5C;AAQK,MAAMI,gCAAgCJ,kBAE3C"}

package/features/tenancy/UpdateTenant/events.d.ts

@@ -0,0 +1,19 @@
+import { DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+export interface TenantBeforeUpdatePayload {
+    tenant: Tenant;
+    inputData: Record<string, any>;
+    updateData: Partial<Tenant>;
+}
+export interface TenantAfterUpdatePayload {
+    tenant: Tenant;
+    inputData: Record<string, any>;
+}
+export declare class TenantBeforeUpdateEvent extends DomainEvent<TenantBeforeUpdatePayload> {
+    eventType: "tenant.beforeUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>>;
+}
+export declare class TenantAfterUpdateEvent extends DomainEvent<TenantAfterUpdatePayload> {
+    eventType: "tenant.afterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantAfterUpdatePayload>>>;
+}