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

package/features/tenancy/GetTenantById/GetTenantByIdUseCase.d.ts

@@ -0,0 +1,9 @@
+import { GetTenantByIdUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { GetTenantByIdRepository } from "./abstractions.js";
+declare class GetTenantByIdUseCaseImpl implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetTenantByIdRepository.Interface);
+    execute(id: string): UseCaseAbstraction.Result;
+}
+export declare const GetTenantByIdUseCase: import("@webiny/di").Implementation<typeof GetTenantByIdUseCaseImpl>;
+export {};

package/features/tenancy/GetTenantById/GetTenantByIdUseCase.js

@@ -0,0 +1,25 @@
+import { createImplementation } from "@webiny/di";
+import { Result } from "@webiny/feature/api";
+import { GetTenantByIdRepository, GetTenantByIdUseCase } from "./abstractions.js";
+class GetTenantByIdUseCaseImpl {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(id) {
+        const tenant = await this.repository.getById(id);
+        if (!tenant) return Result.fail({
+            type: "NOT_FOUND"
+        });
+        return Result.ok(tenant);
+    }
+}
+const GetTenantByIdUseCase_GetTenantByIdUseCase = createImplementation({
+    abstraction: GetTenantByIdUseCase,
+    implementation: GetTenantByIdUseCaseImpl,
+    dependencies: [
+        GetTenantByIdRepository
+    ]
+});
+export { GetTenantByIdUseCase_GetTenantByIdUseCase as GetTenantByIdUseCase };
+
+//# sourceMappingURL=GetTenantByIdUseCase.js.map

package/features/tenancy/GetTenantById/GetTenantByIdUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/GetTenantById/GetTenantByIdUseCase.js","sources":["../../../../src/features/tenancy/GetTenantById/GetTenantByIdUseCase.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { Result } from \"@webiny/feature/api\";\nimport { GetTenantByIdUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { GetTenantByIdRepository } from \"./abstractions.js\";\n\nclass GetTenantByIdUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetTenantByIdRepository.Interface) {}\n\n    async execute(id: string): UseCaseAbstraction.Result {\n        const tenant = await this.repository.getById(id);\n\n        if (!tenant) {\n            return Result.fail<UseCaseAbstraction.Error>({ type: \"NOT_FOUND\" });\n        }\n\n        return Result.ok(tenant);\n    }\n}\n\nexport const GetTenantByIdUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: GetTenantByIdUseCaseImpl,\n    dependencies: [GetTenantByIdRepository]\n});\n"],"names":["GetTenantByIdUseCaseImpl","repository","id","tenant","Result","GetTenantByIdUseCase","createImplementation","UseCaseAbstraction","GetTenantByIdRepository"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,UAA6C,CAAE;aAA/CA,UAAU,GAAVA;IAAgD;IAEpE,MAAM,QAAQC,EAAU,EAA6B;QACjD,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACD;QAE7C,IAAI,CAACC,QACD,OAAOC,OAAO,IAAI,CAA2B;YAAE,MAAM;QAAY;QAGrE,OAAOA,OAAO,EAAE,CAACD;IACrB;AACJ;AAEO,MAAME,4CAAuBC,qBAAqB;IACrD,aAAaC;IACb,gBAAgBP;IAChB,cAAc;QAACQ;KAAwB;AAC3C"}

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

@@ -0,0 +1,34 @@
+import { type Result } from "@webiny/feature/api";
+import type { Tenant } from "../../../types/tenancy.js";
+export type GetTenantByIdError = {
+    type: "NOT_FOUND";
+} | {
+    type: "UNKNOWN";
+    cause: Error;
+};
+export interface IGetTenantByIdUseCase {
+    execute(id: string): Promise<Result<Tenant, GetTenantByIdError>>;
+}
+/** Retrieve a tenant by its ID. */
+export declare const GetTenantByIdUseCase: import("@webiny/di").Abstraction<IGetTenantByIdUseCase>;
+export declare namespace GetTenantByIdUseCase {
+    type Interface = IGetTenantByIdUseCase;
+    type Error = GetTenantByIdError;
+    type Result = ReturnType<IGetTenantByIdUseCase["execute"]>;
+}
+export interface IGetTenantByIdRepository {
+    getById(id: string): Promise<Tenant | null>;
+}
+/** Fetch a tenant by ID from storage. */
+export declare const GetTenantByIdRepository: import("@webiny/di").Abstraction<IGetTenantByIdRepository>;
+export declare namespace GetTenantByIdRepository {
+    type Interface = IGetTenantByIdRepository;
+}
+export interface IGetTenantByIdGateway {
+    getTenantById(id: string): Promise<Tenant | null>;
+}
+/** Storage gateway for tenant retrieval by ID. */
+export declare const GetTenantByIdGateway: import("@webiny/di").Abstraction<IGetTenantByIdGateway>;
+export declare namespace GetTenantByIdGateway {
+    type Interface = IGetTenantByIdGateway;
+}

package/features/tenancy/GetTenantById/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/GetTenantById/abstractions.js","sources":["../../../../src/features/tenancy/GetTenantById/abstractions.ts"],"sourcesContent":["import { type Result, createAbstraction } from \"@webiny/feature/api\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nexport type GetTenantByIdError = { type: \"NOT_FOUND\" } | { type: \"UNKNOWN\"; cause: Error };\n\nexport interface IGetTenantByIdUseCase {\n    execute(id: string): Promise<Result<Tenant, GetTenantByIdError>>;\n}\n\n/** Retrieve a tenant by its ID. */\nexport const GetTenantByIdUseCase = createAbstraction<IGetTenantByIdUseCase>(\n    \"Tenancy/GetTenantByIdUseCase\"\n);\n\nexport namespace GetTenantByIdUseCase {\n    export type Interface = IGetTenantByIdUseCase;\n    export type Error = GetTenantByIdError;\n    export type Result = ReturnType<IGetTenantByIdUseCase[\"execute\"]>;\n}\n\nexport interface IGetTenantByIdRepository {\n    getById(id: string): Promise<Tenant | null>;\n}\n\n/** Fetch a tenant by ID from storage. */\nexport const GetTenantByIdRepository = createAbstraction<IGetTenantByIdRepository>(\n    \"Tenancy/GetTenantByIdRepository\"\n);\n\nexport namespace GetTenantByIdRepository {\n    export type Interface = IGetTenantByIdRepository;\n}\n\nexport interface IGetTenantByIdGateway {\n    getTenantById(id: string): Promise<Tenant | null>;\n}\n\n/** Storage gateway for tenant retrieval by ID. */\nexport const GetTenantByIdGateway = createAbstraction<IGetTenantByIdGateway>(\n    \"Tenancy/GetTenantByIdGateway\"\n);\n\nexport namespace GetTenantByIdGateway {\n    export type Interface = IGetTenantByIdGateway;\n}\n"],"names":["GetTenantByIdUseCase","createAbstraction","GetTenantByIdRepository","GetTenantByIdGateway"],"mappings":";AAUO,MAAMA,uBAAuBC,kBAChC;AAcG,MAAMC,0BAA0BD,kBACnC;AAYG,MAAME,uBAAuBF,kBAChC"}

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

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

package/features/tenancy/GetTenantById/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { GetTenantByIdUseCase } from "./GetTenantByIdUseCase.js";
+import { GetTenantByIdRepository } from "./GetTenantByIdRepository.js";
+import { GetTenantByIdGateway } from "./GetTenantByIdGateway.js";
+const GetTenantByIdFeature = createFeature({
+    name: "GetTenantById",
+    register (container) {
+        container.register(GetTenantByIdGateway).inSingletonScope();
+        container.register(GetTenantByIdRepository).inSingletonScope();
+        container.register(GetTenantByIdUseCase);
+    }
+});
+export { GetTenantByIdFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/GetTenantById/feature.js","sources":["../../../../src/features/tenancy/GetTenantById/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { GetTenantByIdUseCase } from \"./GetTenantByIdUseCase.js\";\nimport { GetTenantByIdRepository } from \"./GetTenantByIdRepository.js\";\nimport { GetTenantByIdGateway } from \"./GetTenantByIdGateway.js\";\n\nexport const GetTenantByIdFeature = createFeature({\n    name: \"GetTenantById\",\n    register(container: Container) {\n        // Register gateway (singleton) - auto-wired with DI (depends on TenancyStorageOperations)\n        container.register(GetTenantByIdGateway).inSingletonScope();\n\n        // Register repository (singleton) - auto-wired with DI\n        container.register(GetTenantByIdRepository).inSingletonScope();\n\n        // Register use case (transient) - auto-wired with DI\n        container.register(GetTenantByIdUseCase);\n    }\n});\n"],"names":["GetTenantByIdFeature","createFeature","container","GetTenantByIdGateway","GetTenantByIdRepository","GetTenantByIdUseCase"],"mappings":";;;;AAMO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAoB;QAEzBA,UAAU,QAAQ,CAACC,sBAAsB,gBAAgB;QAGzDD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;QAG5DF,UAAU,QAAQ,CAACG;IACvB;AACJ"}

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

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

package/features/tenancy/GetTenantById/index.js

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

package/features/tenancy/InstallTenant/DependencyResolver.d.ts

@@ -0,0 +1,6 @@
+import { type AppInstallationData, AppInstaller } from "./abstractions.js";
+export declare class DependencyResolver {
+    resolve(installers: AppInstaller.Interface[], requestedInstalls: AppInstallationData[]): string[];
+    private validateDependencies;
+    private topologicalSort;
+}

package/features/tenancy/InstallTenant/DependencyResolver.js

@@ -0,0 +1,61 @@
+import { InstallationDependencyError } from "./errors.js";
+class DependencyResolver {
+    resolve(installers, requestedInstalls) {
+        const nodes = new Map();
+        const installerMap = new Map(installers.map((i)=>[
+                i.appName,
+                i
+            ]));
+        for (const install of requestedInstalls){
+            const installer = installerMap.get(install.app);
+            if (!installer) throw new InstallationDependencyError({
+                reason: `No installer found for app: ${install.app}`
+            });
+            nodes.set(install.app, installer);
+        }
+        for (const installer of installers)if (installer.alwaysRun && !nodes.has(installer.appName)) nodes.set(installer.appName, installer);
+        this.validateDependencies(nodes, installerMap);
+        return this.topologicalSort(nodes);
+    }
+    validateDependencies(nodes, installerMap) {
+        for (const [appName, node] of nodes)for (const dep of node.dependsOn){
+            if (!installerMap.has(dep)) throw new InstallationDependencyError({
+                reason: `App "${appName}" depends on "${dep}", but no installer exists for "${dep}"`
+            });
+            if (!nodes.has(dep)) throw new InstallationDependencyError({
+                reason: `App "${appName}" depends on "${dep}", but "${dep}" is not included in the installation request. Please include "${dep}" in your installation data.`
+            });
+        }
+    }
+    topologicalSort(nodes) {
+        const sorted = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (appName, path = [])=>{
+            if (visited.has(appName)) return;
+            if (visiting.has(appName)) {
+                const cycle = [
+                    ...path,
+                    appName
+                ].join(" -> ");
+                throw new InstallationDependencyError({
+                    reason: `Circular dependency detected: ${cycle}`
+                });
+            }
+            visiting.add(appName);
+            const node = nodes.get(appName);
+            for (const dep of node.dependsOn)visit(dep, [
+                ...path,
+                appName
+            ]);
+            visiting.delete(appName);
+            visited.add(appName);
+            sorted.push(appName);
+        };
+        for (const appName of nodes.keys())visit(appName);
+        return sorted;
+    }
+}
+export { DependencyResolver };
+
+//# sourceMappingURL=DependencyResolver.js.map

package/features/tenancy/InstallTenant/DependencyResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/InstallTenant/DependencyResolver.js","sources":["../../../../src/features/tenancy/InstallTenant/DependencyResolver.ts"],"sourcesContent":["import { InstallationDependencyError } from \"./errors.js\";\nimport { type AppInstallationData, AppInstaller } from \"./abstractions.js\";\n\nexport class DependencyResolver {\n    resolve(\n        installers: AppInstaller.Interface[],\n        requestedInstalls: AppInstallationData[]\n    ): string[] {\n        const nodes = new Map<string, AppInstaller.Interface>();\n        const installerMap = new Map(installers.map(i => [i.appName, i]));\n\n        // First, add all requested installers\n        for (const install of requestedInstalls) {\n            const installer = installerMap.get(install.app);\n            if (!installer) {\n                throw new InstallationDependencyError({\n                    reason: `No installer found for app: ${install.app}`\n                });\n            }\n\n            nodes.set(install.app, installer);\n        }\n\n        // Then, add all installers with alwaysRun === true that aren't already included\n        for (const installer of installers) {\n            if (installer.alwaysRun && !nodes.has(installer.appName)) {\n                nodes.set(installer.appName, installer);\n            }\n        }\n\n        this.validateDependencies(nodes, installerMap);\n        return this.topologicalSort(nodes);\n    }\n\n    private validateDependencies(\n        nodes: Map<string, AppInstaller.Interface>,\n        installerMap: Map<string, AppInstaller.Interface>\n    ): void {\n        for (const [appName, node] of nodes) {\n            for (const dep of node.dependsOn) {\n                if (!installerMap.has(dep)) {\n                    throw new InstallationDependencyError({\n                        reason: `App \"${appName}\" depends on \"${dep}\", but no installer exists for \"${dep}\"`\n                    });\n                }\n\n                if (!nodes.has(dep)) {\n                    throw new InstallationDependencyError({\n                        reason:\n                            `App \"${appName}\" depends on \"${dep}\", but \"${dep}\" is not included in the installation request. ` +\n                            `Please include \"${dep}\" in your installation data.`\n                    });\n                }\n            }\n        }\n    }\n\n    private topologicalSort(nodes: Map<string, AppInstaller.Interface>): string[] {\n        const sorted: string[] = [];\n        const visited = new Set<string>();\n        const visiting = new Set<string>();\n\n        const visit = (appName: string, path: string[] = []): void => {\n            if (visited.has(appName)) {\n                return;\n            }\n\n            if (visiting.has(appName)) {\n                const cycle = [...path, appName].join(\" -> \");\n                throw new InstallationDependencyError({\n                    reason: `Circular dependency detected: ${cycle}`\n                });\n            }\n\n            visiting.add(appName);\n            const node = nodes.get(appName)!;\n\n            for (const dep of node.dependsOn) {\n                visit(dep, [...path, appName]);\n            }\n\n            visiting.delete(appName);\n            visited.add(appName);\n            sorted.push(appName);\n        };\n\n        for (const appName of nodes.keys()) {\n            visit(appName);\n        }\n\n        return sorted;\n    }\n}\n"],"names":["DependencyResolver","installers","requestedInstalls","nodes","Map","installerMap","i","install","installer","InstallationDependencyError","appName","node","dep","sorted","visited","Set","visiting","visit","path","cycle"],"mappings":";AAGO,MAAMA;IACT,QACIC,UAAoC,EACpCC,iBAAwC,EAChC;QACR,MAAMC,QAAQ,IAAIC;QAClB,MAAMC,eAAe,IAAID,IAAIH,WAAW,GAAG,CAACK,CAAAA,IAAK;gBAACA,EAAE,OAAO;gBAAEA;aAAE;QAG/D,KAAK,MAAMC,WAAWL,kBAAmB;YACrC,MAAMM,YAAYH,aAAa,GAAG,CAACE,QAAQ,GAAG;YAC9C,IAAI,CAACC,WACD,MAAM,IAAIC,4BAA4B;gBAClC,QAAQ,CAAC,4BAA4B,EAAEF,QAAQ,GAAG,EAAE;YACxD;YAGJJ,MAAM,GAAG,CAACI,QAAQ,GAAG,EAAEC;QAC3B;QAGA,KAAK,MAAMA,aAAaP,WACpB,IAAIO,UAAU,SAAS,IAAI,CAACL,MAAM,GAAG,CAACK,UAAU,OAAO,GACnDL,MAAM,GAAG,CAACK,UAAU,OAAO,EAAEA;QAIrC,IAAI,CAAC,oBAAoB,CAACL,OAAOE;QACjC,OAAO,IAAI,CAAC,eAAe,CAACF;IAChC;IAEQ,qBACJA,KAA0C,EAC1CE,YAAiD,EAC7C;QACJ,KAAK,MAAM,CAACK,SAASC,KAAK,IAAIR,MAC1B,KAAK,MAAMS,OAAOD,KAAK,SAAS,CAAE;YAC9B,IAAI,CAACN,aAAa,GAAG,CAACO,MAClB,MAAM,IAAIH,4BAA4B;gBAClC,QAAQ,CAAC,KAAK,EAAEC,QAAQ,cAAc,EAAEE,IAAI,gCAAgC,EAAEA,IAAI,CAAC,CAAC;YACxF;YAGJ,IAAI,CAACT,MAAM,GAAG,CAACS,MACX,MAAM,IAAIH,4BAA4B;gBAClC,QACI,CAAC,KAAK,EAAEC,QAAQ,cAAc,EAAEE,IAAI,QAAQ,EAAEA,IAC7C,+DAAgB,EAAEA,IAAI,4BAA4B,CAD+C;YAE1G;QAER;IAER;IAEQ,gBAAgBT,KAA0C,EAAY;QAC1E,MAAMU,SAAmB,EAAE;QAC3B,MAAMC,UAAU,IAAIC;QACpB,MAAMC,WAAW,IAAID;QAErB,MAAME,QAAQ,CAACP,SAAiBQ,OAAiB,EAAE;YAC/C,IAAIJ,QAAQ,GAAG,CAACJ,UACZ;YAGJ,IAAIM,SAAS,GAAG,CAACN,UAAU;gBACvB,MAAMS,QAAQ;uBAAID;oBAAMR;iBAAQ,CAAC,IAAI,CAAC;gBACtC,MAAM,IAAID,4BAA4B;oBAClC,QAAQ,CAAC,8BAA8B,EAAEU,OAAO;gBACpD;YACJ;YAEAH,SAAS,GAAG,CAACN;YACb,MAAMC,OAAOR,MAAM,GAAG,CAACO;YAEvB,KAAK,MAAME,OAAOD,KAAK,SAAS,CAC5BM,MAAML,KAAK;mBAAIM;gBAAMR;aAAQ;YAGjCM,SAAS,MAAM,CAACN;YAChBI,QAAQ,GAAG,CAACJ;YACZG,OAAO,IAAI,CAACH;QAChB;QAEA,KAAK,MAAMA,WAAWP,MAAM,IAAI,GAC5Bc,MAAMP;QAGV,OAAOG;IACX;AACJ"}

package/features/tenancy/InstallTenant/InstallTenantUseCase.d.ts

@@ -0,0 +1,20 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "../../../features/eventPublisher/index.js";
+import { InstallTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { AppInstaller } from "./abstractions.js";
+import { InstallTenantError, InstallationDependencyError } from "./errors.js";
+import type { TenantInstallationInput } from "./abstractions.js";
+import { UpdateTenantUseCase } from "../../../features/tenancy/UpdateTenant/index.js";
+import { TenantContext } from "../../../exports/api/tenancy.js";
+declare class InstallTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private tenantContext;
+    private eventPublisher;
+    private appInstallers;
+    private updateTenantUseCase;
+    private resolver;
+    constructor(tenantContext: TenantContext.Interface, eventPublisher: EventPublisher.Interface, appInstallers: AppInstaller.Interface[], updateTenantUseCase: UpdateTenantUseCase.Interface);
+    execute({ tenant, installationInput }: TenantInstallationInput): Promise<Result<void, never> | Result<never, InstallTenantError> | Result<never, InstallationDependencyError>>;
+    private rollback;
+}
+export declare const InstallTenantUseCase: import("@webiny/di").Implementation<typeof InstallTenantUseCaseImpl>;
+export {};

package/features/tenancy/InstallTenant/InstallTenantUseCase.js

@@ -0,0 +1,115 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "../../eventPublisher/index.js";
+import { AppInstaller, InstallTenantUseCase } from "./abstractions.js";
+import { InstallTenantError, InstallationDependencyError } from "./errors.js";
+import { TenantInstalledEvent } from "./events.js";
+import { DependencyResolver } from "./DependencyResolver.js";
+import { UpdateTenantUseCase } from "../UpdateTenant/index.js";
+import { TenantContext } from "../../../exports/api/tenancy.js";
+class InstallTenantUseCaseImpl {
+    constructor(tenantContext, eventPublisher, appInstallers, updateTenantUseCase){
+        this.tenantContext = tenantContext;
+        this.eventPublisher = eventPublisher;
+        this.appInstallers = appInstallers;
+        this.updateTenantUseCase = updateTenantUseCase;
+        this.resolver = new DependencyResolver();
+    }
+    async execute({ tenant, installationInput }) {
+        const installerMap = new Map(this.appInstallers.map((installer)=>[
+                installer.appName,
+                installer
+            ]));
+        const dataMap = new Map(installationInput.map((install)=>[
+                install.app,
+                install.data
+            ]));
+        let installationOrder;
+        try {
+            installationOrder = this.resolver.resolve(this.appInstallers, installationInput);
+        } catch (error) {
+            if (error instanceof InstallationDependencyError) return Result.fail(error);
+            return Result.fail(new InstallationDependencyError({
+                reason: error instanceof Error ? error.message : String(error)
+            }));
+        }
+        const installedApps = [];
+        try {
+            const result = await this.tenantContext.withTenant(tenant, async ()=>{
+                for (const appName of installationOrder){
+                    const installer = installerMap.get(appName);
+                    const data = dataMap.get(appName);
+                    try {
+                        await installer.install(tenant, data);
+                        installedApps.push({
+                            appName,
+                            installer
+                        });
+                    } catch (error) {
+                        console.error(`✗ ${appName} installation failed:`, error);
+                        await this.rollback(tenant, installedApps);
+                        return Result.fail(new InstallTenantError({
+                            reason: error instanceof Error ? error.message : String(error),
+                            failedApp: appName,
+                            installedApps: installedApps.map((i)=>i.appName),
+                            cause: error instanceof Error ? error : void 0
+                        }));
+                    }
+                }
+                return Result.ok();
+            });
+            if (result.isFail()) return result;
+            await this.updateTenantUseCase.execute(tenant.id, {
+                isInstalled: true,
+                status: "enabled"
+            });
+            await this.eventPublisher.publish(new TenantInstalledEvent({
+                tenant: tenant,
+                installedApps: installationOrder
+            }));
+            return Result.ok();
+        } catch (error) {
+            await this.rollback(tenant, installedApps);
+            return Result.fail(new InstallTenantError({
+                reason: error instanceof Error ? error.message : String(error),
+                failedApp: "unknown",
+                installedApps: installedApps.map((i)=>i.appName),
+                cause: error instanceof Error ? error : void 0
+            }));
+        }
+    }
+    async rollback(tenant, installedApps) {
+        if (0 === installedApps.length) return;
+        const errors = [];
+        for(let i = installedApps.length - 1; i >= 0; i--){
+            const { appName, installer } = installedApps[i];
+            try {
+                await installer.uninstall(tenant);
+            } catch (error) {
+                console.error(`✗ Failed to rollback ${appName}:`, error);
+                errors.push({
+                    appName,
+                    error: error
+                });
+            }
+        }
+        if (errors.length > 0) console.error(`Warning: ${errors.length} rollback(s) failed:`, errors.map((e)=>`${e.appName}: ${e.error.message}`).join(", "));
+    }
+}
+const InstallTenantUseCase_InstallTenantUseCase = createImplementation({
+    abstraction: InstallTenantUseCase,
+    implementation: InstallTenantUseCaseImpl,
+    dependencies: [
+        TenantContext,
+        EventPublisher,
+        [
+            AppInstaller,
+            {
+                multiple: true
+            }
+        ],
+        UpdateTenantUseCase
+    ]
+});
+export { InstallTenantUseCase_InstallTenantUseCase as InstallTenantUseCase };
+
+//# sourceMappingURL=InstallTenantUseCase.js.map

package/features/tenancy/InstallTenant/InstallTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/InstallTenant/InstallTenantUseCase.js","sources":["../../../../src/features/tenancy/InstallTenant/InstallTenantUseCase.ts"],"sourcesContent":["import { Result, createImplementation } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"~/features/eventPublisher/index.js\";\nimport { InstallTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { AppInstaller } from \"./abstractions.js\";\nimport { InstallTenantError, InstallationDependencyError } from \"./errors.js\";\nimport { TenantInstalledEvent } from \"./events.js\";\nimport { DependencyResolver } from \"./DependencyResolver.js\";\nimport type { TenantInstallationInput } from \"./abstractions.js\";\nimport { UpdateTenantUseCase } from \"~/features/tenancy/UpdateTenant/index.js\";\nimport { TenantContext } from \"~/exports/api/tenancy.js\";\n\nclass InstallTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    private resolver: DependencyResolver;\n\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private appInstallers: AppInstaller.Interface[],\n        private updateTenantUseCase: UpdateTenantUseCase.Interface\n    ) {\n        this.resolver = new DependencyResolver();\n    }\n\n    async execute({ tenant, installationInput }: TenantInstallationInput) {\n        const installerMap = new Map(\n            this.appInstallers.map(installer => [installer.appName, installer])\n        );\n\n        const dataMap = new Map(installationInput.map(install => [install.app, install.data]));\n\n        // Resolve installation order\n        let installationOrder: string[];\n        try {\n            installationOrder = this.resolver.resolve(this.appInstallers, installationInput);\n        } catch (error) {\n            if (error instanceof InstallationDependencyError) {\n                return Result.fail(error);\n            }\n            return Result.fail(\n                new InstallationDependencyError({\n                    reason: error instanceof Error ? error.message : String(error)\n                })\n            );\n        }\n\n        const installedApps: Array<{ appName: string; installer: AppInstaller.Interface }> = [];\n\n        try {\n            /**\n             * We must run installers in the context of the tenant being installed!\n             */\n            const result = await this.tenantContext.withTenant(tenant, async () => {\n                // Execute installations in order\n                for (const appName of installationOrder) {\n                    const installer = installerMap.get(appName)!;\n                    const data = dataMap.get(appName)!;\n\n                    try {\n                        await installer.install(tenant, data);\n                        installedApps.push({ appName, installer });\n                    } catch (error) {\n                        // Installation failed - rollback everything\n                        console.error(`✗ ${appName} installation failed:`, error);\n                        await this.rollback(tenant, installedApps);\n\n                        return Result.fail(\n                            new InstallTenantError({\n                                reason: error instanceof Error ? error.message : String(error),\n                                failedApp: appName,\n                                installedApps: installedApps.map(i => i.appName),\n                                cause: error instanceof Error ? error : undefined\n                            })\n                        );\n                    }\n                }\n                return Result.ok();\n            });\n\n            if (result.isFail()) {\n                return result;\n            }\n\n            /**\n             * Back to root tenant context.\n             */\n\n            // Mark the tenant as installed\n            await this.updateTenantUseCase.execute(tenant.id, {\n                isInstalled: true,\n                status: \"enabled\"\n            });\n\n            // Publish the installed event\n            await this.eventPublisher.publish(\n                new TenantInstalledEvent({\n                    tenant: tenant,\n                    installedApps: installationOrder\n                })\n            );\n\n            return Result.ok();\n        } catch (error) {\n            // Unexpected error during installation loop\n            await this.rollback(tenant, installedApps);\n\n            return Result.fail(\n                new InstallTenantError({\n                    reason: error instanceof Error ? error.message : String(error),\n                    failedApp: \"unknown\",\n                    installedApps: installedApps.map(i => i.appName),\n                    cause: error instanceof Error ? error : undefined\n                })\n            );\n        }\n    }\n\n    private async rollback(\n        tenant: TenantInstallationInput[\"tenant\"],\n        installedApps: Array<{ appName: string; installer: AppInstaller.Interface }>\n    ): Promise<void> {\n        if (installedApps.length === 0) {\n            return;\n        }\n\n        // Rollback in REVERSE order (last installed first)\n        const errors: Array<{ appName: string; error: Error }> = [];\n\n        for (let i = installedApps.length - 1; i >= 0; i--) {\n            const { appName, installer } = installedApps[i];\n\n            try {\n                await installer.uninstall(tenant);\n            } catch (error) {\n                console.error(`✗ Failed to rollback ${appName}:`, error);\n                errors.push({\n                    appName,\n                    error: error as Error\n                });\n            }\n        }\n\n        if (errors.length > 0) {\n            console.error(\n                `Warning: ${errors.length} rollback(s) failed:`,\n                errors.map(e => `${e.appName}: ${e.error.message}`).join(\", \")\n            );\n        }\n    }\n}\n\nexport const InstallTenantUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: InstallTenantUseCaseImpl,\n    dependencies: [\n        TenantContext,\n        EventPublisher,\n        [AppInstaller, { multiple: true }],\n        UpdateTenantUseCase\n    ]\n});\n"],"names":["InstallTenantUseCaseImpl","tenantContext","eventPublisher","appInstallers","updateTenantUseCase","DependencyResolver","tenant","installationInput","installerMap","Map","installer","dataMap","install","installationOrder","error","InstallationDependencyError","Result","Error","String","installedApps","result","appName","data","console","InstallTenantError","i","undefined","TenantInstalledEvent","errors","e","InstallTenantUseCase","createImplementation","UseCaseAbstraction","TenantContext","EventPublisher","AppInstaller","UpdateTenantUseCase"],"mappings":"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"}

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

@@ -0,0 +1,60 @@
+import { Result } from "@webiny/feature/api";
+import type { IEventHandler, DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+import type { TenantInstalledPayload } from "./events.js";
+import { InstallTenantError, InstallationDependencyError } from "./errors.js";
+export type { Tenant };
+/**
+ * Errors
+ */
+export interface IInstallTenantErrors {
+    base: InstallTenantError;
+    dependency: InstallationDependencyError;
+}
+/**
+ * Types
+ */
+export interface AppInstallationData {
+    app: string;
+    data: Record<string, any>;
+}
+export interface TenantInstallationInput {
+    tenant: Tenant;
+    installationInput: AppInstallationData[];
+}
+export interface IAppInstaller<TData = Record<string, any>> {
+    readonly alwaysRun?: boolean;
+    readonly appName: string;
+    readonly dependsOn: string[];
+    /**
+     * Perform the installation
+     * If this succeeds, uninstall() MUST be able to revert it
+     */
+    install(tenant: Tenant, data: TData): Promise<void>;
+    /**
+     * Revert the installation
+     * Called if any subsequent installer fails
+     */
+    uninstall(tenant: Tenant): Promise<void>;
+}
+/** Install an application on a tenant with rollback support. */
+export declare const AppInstaller: import("@webiny/di").Abstraction<IAppInstaller<Record<string, any>>>;
+export declare namespace AppInstaller {
+    type Interface<T = any> = IAppInstaller<T>;
+}
+export interface IInstallTenantUseCase {
+    execute(input: TenantInstallationInput): Promise<Result<void, IInstallTenantErrors[keyof IInstallTenantErrors]>>;
+}
+/** Run all app installers for a tenant. */
+export declare const InstallTenantUseCase: import("@webiny/di").Abstraction<IInstallTenantUseCase>;
+export declare namespace InstallTenantUseCase {
+    type Interface = IInstallTenantUseCase;
+    type Input = TenantInstallationInput;
+    type Errors = IInstallTenantErrors[keyof IInstallTenantErrors];
+}
+/** Hook into tenant lifecycle after a tenant is installed. */
+export declare const TenantInstalledEventHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantInstalledPayload>>>;
+export declare namespace TenantInstalledEventHandler {
+    type Interface = IEventHandler<DomainEvent<TenantInstalledPayload>>;
+    type Event = DomainEvent<TenantInstalledPayload>;
+}

package/features/tenancy/InstallTenant/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/InstallTenant/abstractions.js","sources":["../../../../src/features/tenancy/InstallTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { IEventHandler, DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport type { TenantInstalledPayload } from \"./events.js\";\nimport { InstallTenantError, InstallationDependencyError } from \"./errors.js\";\n\nexport type { Tenant };\n\n/**\n * Errors\n */\nexport interface IInstallTenantErrors {\n    base: InstallTenantError;\n    dependency: InstallationDependencyError;\n}\n\n/**\n * Types\n */\nexport interface AppInstallationData {\n    app: string;\n    data: Record<string, any>;\n}\n\nexport interface TenantInstallationInput {\n    tenant: Tenant;\n    installationInput: AppInstallationData[];\n}\n\nexport interface IAppInstaller<TData = Record<string, any>> {\n    readonly alwaysRun?: boolean;\n    readonly appName: string;\n    readonly dependsOn: string[];\n\n    /**\n     * Perform the installation\n     * If this succeeds, uninstall() MUST be able to revert it\n     */\n    install(tenant: Tenant, data: TData): Promise<void>;\n\n    /**\n     * Revert the installation\n     * Called if any subsequent installer fails\n     */\n    uninstall(tenant: Tenant): Promise<void>;\n}\n\n/** Install an application on a tenant with rollback support. */\nexport const AppInstaller = createAbstraction<IAppInstaller>(\"AppInstaller\");\n\nexport namespace AppInstaller {\n    export type Interface<T = any> = IAppInstaller<T>;\n}\n\nexport interface IInstallTenantUseCase {\n    execute(\n        input: TenantInstallationInput\n    ): Promise<Result<void, IInstallTenantErrors[keyof IInstallTenantErrors]>>;\n}\n\n/** Run all app installers for a tenant. */\nexport const InstallTenantUseCase =\n    createAbstraction<IInstallTenantUseCase>(\"InstallTenantUseCase\");\n\nexport namespace InstallTenantUseCase {\n    export type Interface = IInstallTenantUseCase;\n    export type Input = TenantInstallationInput;\n    export type Errors = IInstallTenantErrors[keyof IInstallTenantErrors];\n}\n\n/** Hook into tenant lifecycle after a tenant is installed. */\nexport const TenantInstalledEventHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantInstalledPayload>>\n>(\"TenantInstalledEventHandler\");\n\nexport namespace TenantInstalledEventHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantInstalledPayload>>;\n    export type Event = DomainEvent<TenantInstalledPayload>;\n}\n"],"names":["AppInstaller","createAbstraction","InstallTenantUseCase","TenantInstalledEventHandler"],"mappings":";AAgDO,MAAMA,eAAeC,kBAAiC;AAatD,MAAMC,uBACTD,kBAAyC;AAStC,MAAME,8BAA8BF,kBAEzC"}

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

@@ -0,0 +1,19 @@
+import { BaseError } from "@webiny/feature/api";
+type InstallTenantErrorData = {
+    reason: string;
+    failedApp: string;
+    installedApps: string[];
+    cause?: Error;
+};
+export declare class InstallTenantError extends BaseError<InstallTenantErrorData> {
+    readonly code: "INSTALL_TENANT";
+    constructor(data: InstallTenantErrorData);
+}
+type InstallationDependencyErrorData = {
+    reason: string;
+};
+export declare class InstallationDependencyError extends BaseError<InstallationDependencyErrorData> {
+    readonly code: "INSTALLATION_DEPENDENCY";
+    constructor(data: InstallationDependencyErrorData);
+}
+export {};

package/features/tenancy/InstallTenant/errors.js

@@ -0,0 +1,20 @@
+import { BaseError } from "@webiny/feature/api";
+class InstallTenantError extends BaseError {
+    constructor(data){
+        super({
+            message: "Installation failed",
+            data
+        }), this.code = "INSTALL_TENANT";
+    }
+}
+class InstallationDependencyError extends BaseError {
+    constructor(data){
+        super({
+            message: `Installation dependency error: ${data.reason}`,
+            data
+        }), this.code = "INSTALLATION_DEPENDENCY";
+    }
+}
+export { InstallTenantError, InstallationDependencyError };
+
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/InstallTenant/errors.js","sources":["../../../../src/features/tenancy/InstallTenant/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\ntype InstallTenantErrorData = {\n    reason: string;\n    failedApp: string;\n    installedApps: string[];\n    cause?: Error;\n};\n\nexport class InstallTenantError extends BaseError<InstallTenantErrorData> {\n    override readonly code = \"INSTALL_TENANT\" as const;\n\n    constructor(data: InstallTenantErrorData) {\n        super({\n            message: \"Installation failed\",\n            data\n        });\n    }\n}\n\ntype InstallationDependencyErrorData = {\n    reason: string;\n};\n\nexport class InstallationDependencyError extends BaseError<InstallationDependencyErrorData> {\n    override readonly code = \"INSTALLATION_DEPENDENCY\" as const;\n\n    constructor(data: InstallationDependencyErrorData) {\n        super({\n            message: `Installation dependency error: ${data.reason}`,\n            data\n        });\n    }\n}\n"],"names":["InstallTenantError","BaseError","data","InstallationDependencyError"],"mappings":";AASO,MAAMA,2BAA2BC;IAGpC,YAAYC,IAA4B,CAAE;QACtC,KAAK,CAAC;YACF,SAAS;YACTA;QACJ,SANc,IAAI,GAAG;IAOzB;AACJ;AAMO,MAAMC,oCAAoCF;IAG7C,YAAYC,IAAqC,CAAE;QAC/C,KAAK,CAAC;YACF,SAAS,CAAC,+BAA+B,EAAEA,KAAK,MAAM,EAAE;YACxDA;QACJ,SANc,IAAI,GAAG;IAOzB;AACJ"}

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

@@ -0,0 +1,10 @@
+import { DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+export interface TenantInstalledPayload {
+    tenant: Tenant;
+    installedApps: string[];
+}
+export declare class TenantInstalledEvent extends DomainEvent<TenantInstalledPayload> {
+    eventType: "tenant.installed";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantInstalledPayload>>>;
+}

package/features/tenancy/InstallTenant/events.js

@@ -0,0 +1,13 @@
+import { DomainEvent } from "../../eventPublisher/index.js";
+import { TenantInstalledEventHandler } from "./abstractions.js";
+class TenantInstalledEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TenantInstalledEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "tenant.installed";
+    }
+}
+export { TenantInstalledEvent };
+
+//# sourceMappingURL=events.js.map

package/features/tenancy/InstallTenant/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/InstallTenant/events.js","sources":["../../../../src/features/tenancy/InstallTenant/events.ts"],"sourcesContent":["import { DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { TenantInstalledEventHandler } from \"./abstractions.js\";\n\nexport interface TenantInstalledPayload {\n    tenant: Tenant;\n    installedApps: string[];\n}\n\nexport class TenantInstalledEvent extends DomainEvent<TenantInstalledPayload> {\n    eventType = \"tenant.installed\" as const;\n\n    getHandlerAbstraction() {\n        return TenantInstalledEventHandler;\n    }\n}\n"],"names":["TenantInstalledEvent","DomainEvent","TenantInstalledEventHandler"],"mappings":";;AASO,MAAMA,6BAA6BC;IAGtC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB"}

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

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

package/features/tenancy/InstallTenant/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/InstallTenant/feature.js","sources":["../../../../src/features/tenancy/InstallTenant/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { InstallTenantUseCase } from \"./InstallTenantUseCase.js\";\n\nexport const InstallTenantFeature = createFeature({\n    name: \"InstallTenant\",\n    register(container: Container) {\n        container.register(InstallTenantUseCase);\n    }\n});\n"],"names":["InstallTenantFeature","createFeature","container","InstallTenantUseCase"],"mappings":";;AAIO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAoB;QACzBA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

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

@@ -0,0 +1,5 @@
+export { InstallTenantFeature } from "./feature.js";
+export { InstallTenantUseCase, AppInstaller, TenantInstalledEventHandler, type AppInstallationData, type TenantInstallationInput } from "./abstractions.js";
+export { DependencyResolver } from "./DependencyResolver.js";
+export { InstallTenantError, InstallationDependencyError } from "./errors.js";
+export { TenantInstalledEvent, type TenantInstalledPayload } from "./events.js";

package/features/tenancy/InstallTenant/index.js

@@ -0,0 +1,5 @@
+export { InstallTenantFeature } from "./feature.js";
+export { AppInstaller, InstallTenantUseCase, TenantInstalledEventHandler } from "./abstractions.js";
+export { DependencyResolver } from "./DependencyResolver.js";
+export { InstallTenantError, InstallationDependencyError } from "./errors.js";
+export { TenantInstalledEvent } from "./events.js";

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

@@ -0,0 +1,10 @@
+import { ListTenantsGateway as GatewayAbstraction } from "./abstractions.js";
+import type { ListTenantsParams } from "../../../types/tenancy.js";
+import { TenancyStorageOperations } from "../../../features/tenancy/shared/storageOperations.js";
+declare class ListTenantsGatewayImpl implements GatewayAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: TenancyStorageOperations.Interface);
+    listTenants(params?: ListTenantsParams): Promise<import("~/types/tenancy.js").Tenant[]>;
+}
+export declare const ListTenantsGateway: import("@webiny/di").Implementation<typeof ListTenantsGatewayImpl>;
+export {};

package/features/tenancy/ListTenants/ListTenantsGateway.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/tenancy/ListTenants/ListTenantsGateway.js","sources":["../../../../src/features/tenancy/ListTenants/ListTenantsGateway.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { ListTenantsGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport type { ListTenantsParams } from \"~/types/tenancy.js\";\nimport { TenancyStorageOperations } from \"~/features/tenancy/shared/storageOperations.js\";\n\nclass ListTenantsGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private storageOperations: TenancyStorageOperations.Interface) {}\n\n    async listTenants(params?: ListTenantsParams) {\n        return await this.storageOperations.listTenants(params);\n    }\n}\n\nexport const ListTenantsGateway = createImplementation({\n    abstraction: GatewayAbstraction,\n    implementation: ListTenantsGatewayImpl,\n    dependencies: [TenancyStorageOperations]\n});\n"],"names":["ListTenantsGatewayImpl","storageOperations","params","ListTenantsGateway","createImplementation","GatewayAbstraction","TenancyStorageOperations"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,iBAAqD,CAAE;aAAvDA,iBAAiB,GAAjBA;IAAwD;IAE5E,MAAM,YAAYC,MAA0B,EAAE;QAC1C,OAAO,MAAM,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAACA;IACpD;AACJ;AAEO,MAAMC,wCAAqBC,qBAAqB;IACnD,aAAaC;IACb,gBAAgBL;IAChB,cAAc;QAACM;KAAyB;AAC5C"}

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

@@ -0,0 +1,10 @@
+import { ListTenantsRepository as RepositoryAbstraction } from "./abstractions.js";
+import { ListTenantsGateway } from "./abstractions.js";
+import type { ListTenantsParams } from "../../../types/tenancy.js";
+declare class ListTenantsRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    constructor(gateway: ListTenantsGateway.Interface);
+    list(params?: ListTenantsParams): Promise<import("~/types/tenancy.js").Tenant[]>;
+}
+export declare const ListTenantsRepository: import("@webiny/di").Implementation<typeof ListTenantsRepositoryImpl>;
+export {};