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

package/api/features/EnableTenant/EnableTenantUseCase.js

@@ -0,0 +1,55 @@
+import { EnableTenantUseCase } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { UpdateTenantUseCase } from "@webiny/api-core/features/tenancy/UpdateTenant";
+import { UpdateTenantUseCase as abstractions_js_UpdateTenantUseCase } from "../UpdateTenant/abstractions.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+import { TenantAfterEnableEvent, TenantBeforeEnableEvent } from "./events.js";
+import { TenantPersistenceError } from "../../domain/errors.js";
+class EnableTenantUseCase_EnableTenantUseCase {
+    constructor(identityContext, eventPublisher, coreUpdateTenant, tmUpdateTenant, tmGetTenantById){
+        this.identityContext = identityContext;
+        this.eventPublisher = eventPublisher;
+        this.coreUpdateTenant = coreUpdateTenant;
+        this.tmUpdateTenant = tmUpdateTenant;
+        this.tmGetTenantById = tmGetTenantById;
+    }
+    async execute(tenantId) {
+        if (!this.identityContext.getPermission("tm.tenant")) return Result.fail(new NotAuthorizedError({
+            message: "Not authorized to enable tenants."
+        }));
+        const getTenantResult = await this.tmGetTenantById.execute(tenantId);
+        if (getTenantResult.isFail()) return Result.fail(getTenantResult.error);
+        const tenant = getTenantResult.value;
+        await this.eventPublisher.publish(new TenantBeforeEnableEvent({
+            tenant
+        }));
+        const apiCoreResult = await this.coreUpdateTenant.execute(tenantId, {
+            status: "enabled"
+        });
+        if (apiCoreResult.isFail()) return Result.fail(new TenantPersistenceError(new Error(`Failed to update api-core tenant: ${apiCoreResult.error}`)));
+        const updatedTenantResult = await this.tmUpdateTenant.execute(tenantId, {
+            status: "enabled"
+        });
+        if (updatedTenantResult.isFail()) return Result.fail(updatedTenantResult.error);
+        await this.eventPublisher.publish(new TenantAfterEnableEvent({
+            tenant: updatedTenantResult.value
+        }));
+        return Result.ok();
+    }
+}
+const EnableTenant_EnableTenantUseCase = EnableTenantUseCase.createImplementation({
+    implementation: EnableTenantUseCase_EnableTenantUseCase,
+    dependencies: [
+        IdentityContext,
+        EventPublisher,
+        UpdateTenantUseCase,
+        abstractions_js_UpdateTenantUseCase,
+        GetTenantByIdUseCase
+    ]
+});
+export default EnableTenant_EnableTenantUseCase;
+
+//# sourceMappingURL=EnableTenantUseCase.js.map

package/api/features/EnableTenant/EnableTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/EnableTenant/EnableTenantUseCase.js","sources":["../../../../src/api/features/EnableTenant/EnableTenantUseCase.ts"],"sourcesContent":["import { EnableTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport { UpdateTenantUseCase as ApiCoreUpdateTenant } from \"@webiny/api-core/features/tenancy/UpdateTenant\";\nimport { UpdateTenantUseCase as TenantManagerUpdateTenant } from \"../UpdateTenant/abstractions.js\";\nimport { GetTenantByIdUseCase } from \"../GetTenantById/abstractions.js\";\nimport { TenantBeforeEnableEvent, TenantAfterEnableEvent } from \"./events.js\";\nimport { TenantPersistenceError } from \"../../domain/errors.js\";\n\nclass EnableTenantUseCase implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private coreUpdateTenant: ApiCoreUpdateTenant.Interface,\n        private tmUpdateTenant: TenantManagerUpdateTenant.Interface,\n        private tmGetTenantById: GetTenantByIdUseCase.Interface\n    ) {}\n\n    async execute(tenantId: string): Promise<Result<void, UseCaseAbstraction.Error>> {\n        // Authorization checks\n        if (!this.identityContext.getPermission(\"tm.tenant\")) {\n            return Result.fail(\n                new NotAuthorizedError({ message: \"Not authorized to enable tenants.\" })\n            );\n        }\n\n        // Get current tenant to verify it exists\n        const getTenantResult = await this.tmGetTenantById.execute(tenantId);\n        if (getTenantResult.isFail()) {\n            return Result.fail(getTenantResult.error);\n        }\n\n        const tenant = getTenantResult.value;\n\n        // Publish before event\n        await this.eventPublisher.publish(new TenantBeforeEnableEvent({ tenant }));\n\n        // Update api-core tenant first\n        const apiCoreResult = await this.coreUpdateTenant.execute(tenantId, {\n            status: \"enabled\"\n        });\n\n        if (apiCoreResult.isFail()) {\n            return Result.fail(\n                new TenantPersistenceError(\n                    new Error(`Failed to update api-core tenant: ${apiCoreResult.error}`)\n                )\n            );\n        }\n\n        // Update tenant-manager CMS entry\n        const updatedTenantResult = await this.tmUpdateTenant.execute(tenantId, {\n            status: \"enabled\"\n        });\n\n        if (updatedTenantResult.isFail()) {\n            return Result.fail(updatedTenantResult.error);\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new TenantAfterEnableEvent({ tenant: updatedTenantResult.value })\n        );\n\n        return Result.ok();\n    }\n}\n\nexport default UseCaseAbstraction.createImplementation({\n    implementation: EnableTenantUseCase,\n    dependencies: [\n        IdentityContext,\n        EventPublisher,\n        ApiCoreUpdateTenant,\n        TenantManagerUpdateTenant,\n        GetTenantByIdUseCase\n    ]\n});\n"],"names":["EnableTenantUseCase","identityContext","eventPublisher","coreUpdateTenant","tmUpdateTenant","tmGetTenantById","tenantId","Result","NotAuthorizedError","getTenantResult","tenant","TenantBeforeEnableEvent","apiCoreResult","TenantPersistenceError","Error","updatedTenantResult","TenantAfterEnableEvent","UseCaseAbstraction","IdentityContext","EventPublisher","ApiCoreUpdateTenant","TenantManagerUpdateTenant","GetTenantByIdUseCase"],"mappings":";;;;;;;;;;AAWA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,cAAwC,EACxCC,gBAA+C,EAC/CC,cAAmD,EACnDC,eAA+C,CACzD;aALUJ,eAAe,GAAfA;aACAC,cAAc,GAAdA;aACAC,gBAAgB,GAAhBA;aACAC,cAAc,GAAdA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAM,QAAQC,QAAgB,EAAmD;QAE7E,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,cACpC,OAAOC,OAAO,IAAI,CACd,IAAIC,mBAAmB;YAAE,SAAS;QAAoC;QAK9E,MAAMC,kBAAkB,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACH;QAC3D,IAAIG,gBAAgB,MAAM,IACtB,OAAOF,OAAO,IAAI,CAACE,gBAAgB,KAAK;QAG5C,MAAMC,SAASD,gBAAgB,KAAK;QAGpC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,IAAIE,wBAAwB;YAAED;QAAO;QAGvE,MAAME,gBAAgB,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACN,UAAU;YAChE,QAAQ;QACZ;QAEA,IAAIM,cAAc,MAAM,IACpB,OAAOL,OAAO,IAAI,CACd,IAAIM,uBACA,IAAIC,MAAM,CAAC,kCAAkC,EAAEF,cAAc,KAAK,EAAE;QAMhF,MAAMG,sBAAsB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACT,UAAU;YACpE,QAAQ;QACZ;QAEA,IAAIS,oBAAoB,MAAM,IAC1B,OAAOR,OAAO,IAAI,CAACQ,oBAAoB,KAAK;QAIhD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,uBAAuB;YAAE,QAAQD,oBAAoB,KAAK;QAAC;QAGnE,OAAOR,OAAO,EAAE;IACpB;AACJ;AAEA,yCAAeU,oBAAAA,oBAAuC,CAAC;IACnD,gBAAgBjB;IAChB,cAAc;QACVkB;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/api/features/EnableTenant/abstractions.d.ts

@@ -0,0 +1,19 @@
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { TenantModelNotFoundError, TenantNotFoundError, TenantPersistenceError } from "../../domain/errors.js";
+export interface IEnableTenantUseCase {
+    execute(tenantId: string): Promise<Result<void, EnableTenantUseCase.Error>>;
+}
+export interface IEnableTenantUseCaseErrors {
+    notAuthorized: NotAuthorizedError;
+    notFound: TenantNotFoundError;
+    persistence: TenantPersistenceError;
+    modelNotFound: TenantModelNotFoundError;
+}
+type UseCaseError = IEnableTenantUseCaseErrors[keyof IEnableTenantUseCaseErrors];
+export declare const EnableTenantUseCase: import("@webiny/di").Abstraction<IEnableTenantUseCase>;
+export declare namespace EnableTenantUseCase {
+    type Interface = IEnableTenantUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/EnableTenant/abstractions.js

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

package/api/features/EnableTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/EnableTenant/abstractions.js","sources":["../../../../src/api/features/EnableTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport {\n    TenantModelNotFoundError,\n    TenantNotFoundError,\n    TenantPersistenceError\n} from \"../../domain/errors.js\";\n\nexport interface IEnableTenantUseCase {\n    execute(tenantId: string): Promise<Result<void, EnableTenantUseCase.Error>>;\n}\n\nexport interface IEnableTenantUseCaseErrors {\n    notAuthorized: NotAuthorizedError;\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n    modelNotFound: TenantModelNotFoundError;\n}\n\ntype UseCaseError = IEnableTenantUseCaseErrors[keyof IEnableTenantUseCaseErrors];\n\nexport const EnableTenantUseCase = createAbstraction<IEnableTenantUseCase>(\n    \"TenantManager/EnableTenantUseCase\"\n);\n\nexport namespace EnableTenantUseCase {\n    export type Interface = IEnableTenantUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["EnableTenantUseCase","createAbstraction"],"mappings":";AAsBO,MAAMA,sBAAsBC,kBAC/B"}

package/api/features/EnableTenant/events.d.ts

@@ -0,0 +1,27 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { Tenant } from "../../../shared/Tenant.js";
+export interface TenantBeforeEnablePayload {
+    tenant: Tenant;
+}
+export interface TenantAfterEnablePayload {
+    tenant: Tenant;
+}
+export declare class TenantBeforeEnableEvent extends DomainEvent<TenantBeforeEnablePayload> {
+    eventType: "tenant.beforeEnable";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<TenantBeforeEnableEvent>>;
+}
+export declare const TenantBeforeEnableEventHandler: import("@webiny/di").Abstraction<IEventHandler<TenantBeforeEnableEvent>>;
+export declare namespace TenantBeforeEnableEventHandler {
+    type Interface = IEventHandler<TenantBeforeEnableEvent>;
+    type Event = TenantBeforeEnableEvent;
+}
+export declare class TenantAfterEnableEvent extends DomainEvent<TenantAfterEnablePayload> {
+    eventType: "tenant.afterEnable";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<TenantAfterEnableEvent>>;
+}
+export declare const TenantAfterEnableEventHandler: import("@webiny/di").Abstraction<IEventHandler<TenantAfterEnableEvent>>;
+export declare namespace TenantAfterEnableEventHandler {
+    type Interface = IEventHandler<TenantAfterEnableEvent>;
+    type Event = TenantAfterEnableEvent;
+}

package/api/features/EnableTenant/events.js

@@ -0,0 +1,23 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class TenantBeforeEnableEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TenantBeforeEnableEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "tenant.beforeEnable";
+    }
+}
+const TenantBeforeEnableEventHandler = createAbstraction("TenantManager/TenantBeforeEnableEventHandler");
+class TenantAfterEnableEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return TenantAfterEnableEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "tenant.afterEnable";
+    }
+}
+const TenantAfterEnableEventHandler = createAbstraction("TenantManager/TenantAfterEnableEventHandler");
+export { TenantAfterEnableEvent, TenantAfterEnableEventHandler, TenantBeforeEnableEvent, TenantBeforeEnableEventHandler };
+
+//# sourceMappingURL=events.js.map

package/api/features/EnableTenant/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/EnableTenant/events.js","sources":["../../../../src/api/features/EnableTenant/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/shared/Tenant.js\";\n\nexport interface TenantBeforeEnablePayload {\n    tenant: Tenant;\n}\n\nexport interface TenantAfterEnablePayload {\n    tenant: Tenant;\n}\n\nexport class TenantBeforeEnableEvent extends DomainEvent<TenantBeforeEnablePayload> {\n    eventType = \"tenant.beforeEnable\" as const;\n\n    getHandlerAbstraction() {\n        return TenantBeforeEnableEventHandler;\n    }\n}\n\nexport const TenantBeforeEnableEventHandler = createAbstraction<\n    IEventHandler<TenantBeforeEnableEvent>\n>(\"TenantManager/TenantBeforeEnableEventHandler\");\n\nexport namespace TenantBeforeEnableEventHandler {\n    export type Interface = IEventHandler<TenantBeforeEnableEvent>;\n    export type Event = TenantBeforeEnableEvent;\n}\n\nexport class TenantAfterEnableEvent extends DomainEvent<TenantAfterEnablePayload> {\n    eventType = \"tenant.afterEnable\" as const;\n\n    getHandlerAbstraction() {\n        return TenantAfterEnableEventHandler;\n    }\n}\n\nexport const TenantAfterEnableEventHandler = createAbstraction<\n    IEventHandler<TenantAfterEnableEvent>\n>(\"TenantManager/TenantAfterEnableEventHandler\");\n\nexport namespace TenantAfterEnableEventHandler {\n    export type Interface = IEventHandler<TenantAfterEnableEvent>;\n    export type Event = TenantAfterEnableEvent;\n}\n"],"names":["TenantBeforeEnableEvent","DomainEvent","TenantBeforeEnableEventHandler","createAbstraction","TenantAfterEnableEvent","TenantAfterEnableEventHandler"],"mappings":";;AAaO,MAAMA,gCAAgCC;IAGzC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,iCAAiCC,kBAE5C;AAOK,MAAMC,+BAA+BH;IAGxC,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,gCAAgCF,kBAE3C"}

package/api/features/EnableTenant/feature.d.ts

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

package/api/features/EnableTenant/feature.js

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

package/api/features/EnableTenant/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/EnableTenant/feature.js","sources":["../../../../src/api/features/EnableTenant/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport EnableTenantUseCase from \"./EnableTenantUseCase.js\";\n\nexport const EnableTenantFeature = createFeature({\n    name: \"EnableTenant\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(EnableTenantUseCase);\n    }\n});\n"],"names":["EnableTenantFeature","createFeature","container","EnableTenantUseCase"],"mappings":";;AAGO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/api/features/GetCurrentTenant/GetCurrentTenantUseCase.d.ts

@@ -0,0 +1,17 @@
+import { Tenant } from "../../../shared/Tenant.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+import { GetCurrentTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { Result } from "@webiny/feature/api";
+declare class GetCurrentTenantUseCase implements UseCaseAbstraction.Interface {
+    private tenantContext;
+    private identityContext;
+    private getTenantByIdUseCase;
+    constructor(tenantContext: TenantContext.Interface, identityContext: IdentityContext.Interface, getTenantByIdUseCase: GetTenantByIdUseCase.Interface);
+    execute(): Promise<Result<Tenant, UseCaseAbstraction.Error>>;
+}
+declare const _default: typeof GetCurrentTenantUseCase & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetCurrentTenantUseCase>;
+};
+export default _default;

package/api/features/GetCurrentTenant/GetCurrentTenantUseCase.js

@@ -0,0 +1,32 @@
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+import { GetCurrentTenantUseCase } from "./abstractions.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/index.js";
+class GetCurrentTenantUseCase_GetCurrentTenantUseCase {
+    constructor(tenantContext, identityContext, getTenantByIdUseCase){
+        this.tenantContext = tenantContext;
+        this.identityContext = identityContext;
+        this.getTenantByIdUseCase = getTenantByIdUseCase;
+    }
+    async execute() {
+        const identity = this.identityContext.getIdentity();
+        if (identity.isAnonymous()) return Result.fail(new NotAuthorizedError());
+        const currentTenant = this.tenantContext.getTenant();
+        const result = await this.identityContext.withoutAuthorization(()=>this.getTenantByIdUseCase.execute(currentTenant.id));
+        if (result.isFail()) return Result.fail(result.error);
+        return Result.ok(result.value);
+    }
+}
+const GetCurrentTenant_GetCurrentTenantUseCase = GetCurrentTenantUseCase.createImplementation({
+    implementation: GetCurrentTenantUseCase_GetCurrentTenantUseCase,
+    dependencies: [
+        TenantContext,
+        IdentityContext,
+        GetTenantByIdUseCase
+    ]
+});
+export default GetCurrentTenant_GetCurrentTenantUseCase;
+
+//# sourceMappingURL=GetCurrentTenantUseCase.js.map

package/api/features/GetCurrentTenant/GetCurrentTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetCurrentTenant/GetCurrentTenantUseCase.js","sources":["../../../../src/api/features/GetCurrentTenant/GetCurrentTenantUseCase.ts"],"sourcesContent":["import { Tenant } from \"~/shared/Tenant.js\";\nimport { GetTenantByIdUseCase } from \"../GetTenantById/abstractions.js\";\nimport { GetCurrentTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/index.js\";\n\nclass GetCurrentTenantUseCase implements UseCaseAbstraction.Interface {\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private identityContext: IdentityContext.Interface,\n        private getTenantByIdUseCase: GetTenantByIdUseCase.Interface\n    ) {}\n\n    async execute(): Promise<Result<Tenant, UseCaseAbstraction.Error>> {\n        const identity = this.identityContext.getIdentity();\n        if (identity.isAnonymous()) {\n            return Result.fail(new NotAuthorizedError());\n        }\n\n        // Get the current tenant from context\n        const currentTenant = this.tenantContext.getTenant();\n\n        const result = await this.identityContext.withoutAuthorization(() => {\n            return this.getTenantByIdUseCase.execute(currentTenant.id);\n        });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport default UseCaseAbstraction.createImplementation({\n    implementation: GetCurrentTenantUseCase,\n    dependencies: [TenantContext, IdentityContext, GetTenantByIdUseCase]\n});\n"],"names":["GetCurrentTenantUseCase","tenantContext","identityContext","getTenantByIdUseCase","identity","Result","NotAuthorizedError","currentTenant","result","UseCaseAbstraction","TenantContext","IdentityContext","GetTenantByIdUseCase"],"mappings":";;;;;;AAQA,MAAMA;IACF,YACYC,aAAsC,EACtCC,eAA0C,EAC1CC,oBAAoD,CAC9D;aAHUF,aAAa,GAAbA;aACAC,eAAe,GAAfA;aACAC,oBAAoB,GAApBA;IACT;IAEH,MAAM,UAA6D;QAC/D,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,IAAIA,SAAS,WAAW,IACpB,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAI3B,MAAMC,gBAAgB,IAAI,CAAC,aAAa,CAAC,SAAS;QAElD,MAAMC,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,oBAAoB,CAAC,IACpD,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAACD,cAAc,EAAE;QAG7D,IAAIC,OAAO,MAAM,IACb,OAAOH,OAAO,IAAI,CAACG,OAAO,KAAK;QAGnC,OAAOH,OAAO,EAAE,CAACG,OAAO,KAAK;IACjC;AACJ;AAEA,iDAAeC,wBAAAA,oBAAuC,CAAC;IACnD,gBAAgBT;IAChB,cAAc;QAACU;QAAeC;QAAiBC;KAAqB;AACxE"}

package/api/features/GetCurrentTenant/abstractions.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import type { Tenant } from "../../../shared/Tenant.js";
+import type { TenantModelNotFoundError, TenantNotFoundError, TenantPersistenceError } from "../../domain/errors.js";
+/**
+ * GetCurrentTenant Use Case
+ * Gets the tenant associated with the current tenant context
+ */
+export interface IGetCurrentTenantUseCase {
+    execute(): Promise<Result<Tenant, UseCaseError>>;
+}
+export interface IGetCurrentTenantUseCaseErrors {
+    notFound: TenantNotFoundError;
+    notAuthorized: NotAuthorizedError;
+    persistence: TenantPersistenceError;
+    modelNotFoundError: TenantModelNotFoundError;
+}
+type UseCaseError = IGetCurrentTenantUseCaseErrors[keyof IGetCurrentTenantUseCaseErrors];
+export declare const GetCurrentTenantUseCase: import("@webiny/di").Abstraction<IGetCurrentTenantUseCase>;
+export declare namespace GetCurrentTenantUseCase {
+    type Interface = IGetCurrentTenantUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/GetCurrentTenant/abstractions.js

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

package/api/features/GetCurrentTenant/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetCurrentTenant/abstractions.js","sources":["../../../../src/api/features/GetCurrentTenant/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport type { Tenant } from \"~/shared/Tenant.js\";\nimport type {\n    TenantModelNotFoundError,\n    TenantNotFoundError,\n    TenantPersistenceError\n} from \"../../domain/errors.js\";\n\n/**\n * GetCurrentTenant Use Case\n * Gets the tenant associated with the current tenant context\n */\nexport interface IGetCurrentTenantUseCase {\n    execute(): Promise<Result<Tenant, UseCaseError>>;\n}\n\nexport interface IGetCurrentTenantUseCaseErrors {\n    notFound: TenantNotFoundError;\n    notAuthorized: NotAuthorizedError;\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n}\n\ntype UseCaseError = IGetCurrentTenantUseCaseErrors[keyof IGetCurrentTenantUseCaseErrors];\n\nexport const GetCurrentTenantUseCase = createAbstraction<IGetCurrentTenantUseCase>(\n    \"TenantManager/GetCurrentTenantUseCase\"\n);\n\nexport namespace GetCurrentTenantUseCase {\n    export type Interface = IGetCurrentTenantUseCase;\n    export type Error = UseCaseError;\n}\n"],"names":["GetCurrentTenantUseCase","createAbstraction"],"mappings":";AA2BO,MAAMA,0BAA0BC,kBACnC"}

package/api/features/GetCurrentTenant/feature.d.ts

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

package/api/features/GetCurrentTenant/feature.js

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

package/api/features/GetCurrentTenant/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetCurrentTenant/feature.js","sources":["../../../../src/api/features/GetCurrentTenant/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport GetCurrentTenantUseCase from \"./GetCurrentTenantUseCase.js\";\n\nexport const GetCurrentTenantFeature = createFeature({\n    name: \"GetCurrentTenant\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(GetCurrentTenantUseCase);\n    }\n});\n"],"names":["GetCurrentTenantFeature","createFeature","container","GetCurrentTenantUseCase"],"mappings":";;AAGO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/api/features/GetTenantById/GetTenantByIdRepository.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { Tenant } from "../../../shared/Tenant.js";
+import { GetTenantByIdRepository as RepositoryAbstraction } from "./abstractions.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/abstractions.js";
+declare class GetTenantByIdRepository implements RepositoryAbstraction.Interface {
+    private tenantContext;
+    private getModelUseCase;
+    private getEntryUseCase;
+    constructor(tenantContext: TenantContext.Interface, getModelUseCase: GetModelUseCase.Interface, getEntryUseCase: GetEntryByIdUseCase.Interface);
+    execute(id: string): Promise<Result<Tenant, RepositoryAbstraction.Error>>;
+}
+declare const _default: typeof GetTenantByIdRepository & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetTenantByIdRepository>;
+};
+export default _default;

package/api/features/GetTenantById/GetTenantByIdRepository.js

@@ -0,0 +1,44 @@
+import { Result } from "@webiny/feature/api";
+import { Tenant } from "../../../shared/Tenant.js";
+import { TENANT_MODEL_ID } from "../../../shared/constants.js";
+import { TenantModelNotFoundError, TenantNotFoundError, TenantPersistenceError } from "../../domain/errors.js";
+import { GetTenantByIdRepository } from "./abstractions.js";
+import { TenantContext } from "@webiny/api-core/exports/api/tenancy.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/abstractions.js";
+import { EntryId } from "@webiny/api-headless-cms/domain/contentEntry/EntryId.js";
+class GetTenantByIdRepository_GetTenantByIdRepository {
+    constructor(tenantContext, getModelUseCase, getEntryUseCase){
+        this.tenantContext = tenantContext;
+        this.getModelUseCase = getModelUseCase;
+        this.getEntryUseCase = getEntryUseCase;
+    }
+    async execute(id) {
+        try {
+            const entryId = EntryId.from(id);
+            const modelResult = await this.getModelUseCase.execute(TENANT_MODEL_ID);
+            if (modelResult.isFail()) return Result.fail(new TenantModelNotFoundError());
+            const entryResult = await this.tenantContext.withRootTenant(()=>this.getEntryUseCase.execute(modelResult.value, entryId.toString()));
+            if (entryResult.isFail()) return Result.fail(new TenantNotFoundError(id));
+            const tenantEntry = entryResult.value;
+            const tenantDto = {
+                id: tenantEntry.entryId,
+                values: tenantEntry.values
+            };
+            return Result.ok(Tenant.from(tenantDto));
+        } catch (error) {
+            return Result.fail(new TenantPersistenceError(error));
+        }
+    }
+}
+const GetTenantById_GetTenantByIdRepository = GetTenantByIdRepository.createImplementation({
+    implementation: GetTenantByIdRepository_GetTenantByIdRepository,
+    dependencies: [
+        TenantContext,
+        GetModelUseCase,
+        GetEntryByIdUseCase
+    ]
+});
+export default GetTenantById_GetTenantByIdRepository;
+
+//# sourceMappingURL=GetTenantByIdRepository.js.map

package/api/features/GetTenantById/GetTenantByIdRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetTenantById/GetTenantByIdRepository.js","sources":["../../../../src/api/features/GetTenantById/GetTenantByIdRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Tenant, TenantDto, TenantValues } from \"~/shared/Tenant.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\nimport {\n    TenantModelNotFoundError,\n    TenantNotFoundError,\n    TenantPersistenceError\n} from \"../../domain/errors.js\";\nimport { GetTenantByIdRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/abstractions.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/domain/contentEntry/EntryId.js\";\n\nclass GetTenantByIdRepository implements RepositoryAbstraction.Interface {\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryUseCase: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<Tenant, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = EntryId.from(id);\n\n            // Get the tenant model\n            const modelResult = await this.getModelUseCase.execute(TENANT_MODEL_ID);\n            if (modelResult.isFail()) {\n                return Result.fail(new TenantModelNotFoundError());\n            }\n\n            // Get the tenant entry\n            const entryResult = await this.tenantContext.withRootTenant(() => {\n                return this.getEntryUseCase.execute<TenantValues>(\n                    modelResult.value,\n                    entryId.toString()\n                );\n            });\n\n            if (entryResult.isFail()) {\n                return Result.fail(new TenantNotFoundError(id));\n            }\n\n            const tenantEntry = entryResult.value;\n\n            const tenantDto: TenantDto = {\n                id: tenantEntry.entryId,\n                values: tenantEntry.values\n            };\n\n            return Result.ok(Tenant.from(tenantDto));\n        } catch (error) {\n            return Result.fail(new TenantPersistenceError(error as Error));\n        }\n    }\n}\n\nexport default RepositoryAbstraction.createImplementation({\n    implementation: GetTenantByIdRepository,\n    dependencies: [TenantContext, GetModelUseCase, GetEntryByIdUseCase]\n});\n"],"names":["GetTenantByIdRepository","tenantContext","getModelUseCase","getEntryUseCase","id","entryId","EntryId","modelResult","TENANT_MODEL_ID","Result","TenantModelNotFoundError","entryResult","TenantNotFoundError","tenantEntry","tenantDto","Tenant","error","TenantPersistenceError","RepositoryAbstraction","TenantContext","GetModelUseCase","GetEntryByIdUseCase"],"mappings":";;;;;;;;;AAcA,MAAMA;IACF,YACYC,aAAsC,EACtCC,eAA0C,EAC1CC,eAA8C,CACxD;aAHUF,aAAa,GAAbA;aACAC,eAAe,GAAfA;aACAC,eAAe,GAAfA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAwD;QAC5E,IAAI;YACA,MAAMC,UAAUC,QAAQ,IAAI,CAACF;YAG7B,MAAMG,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACC;YACvD,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CAAC,IAAIC;YAI3B,MAAMC,cAAc,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,IACjD,IAAI,CAAC,eAAe,CAAC,OAAO,CAC/BJ,YAAY,KAAK,EACjBF,QAAQ,QAAQ;YAIxB,IAAIM,YAAY,MAAM,IAClB,OAAOF,OAAO,IAAI,CAAC,IAAIG,oBAAoBR;YAG/C,MAAMS,cAAcF,YAAY,KAAK;YAErC,MAAMG,YAAuB;gBACzB,IAAID,YAAY,OAAO;gBACvB,QAAQA,YAAY,MAAM;YAC9B;YAEA,OAAOJ,OAAO,EAAE,CAACM,OAAO,IAAI,CAACD;QACjC,EAAE,OAAOE,OAAO;YACZ,OAAOP,OAAO,IAAI,CAAC,IAAIQ,uBAAuBD;QAClD;IACJ;AACJ;AAEA,8CAAeE,wBAAAA,oBAA0C,CAAC;IACtD,gBAAgBlB;IAChB,cAAc;QAACmB;QAAeC;QAAiBC;KAAoB;AACvE"}

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

@@ -0,0 +1,12 @@
+import { Tenant } from "../../../shared/Tenant.js";
+import { GetTenantByIdUseCase as UseCaseAbstraction, GetTenantByIdRepository } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+declare class GetTenantByIdUseCase implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: GetTenantByIdRepository.Interface);
+    execute(id: string): Promise<Result<Tenant, UseCaseAbstraction.Error>>;
+}
+declare const _default: typeof GetTenantByIdUseCase & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetTenantByIdUseCase>;
+};
+export default _default;

package/api/features/GetTenantById/GetTenantByIdUseCase.js

@@ -0,0 +1,23 @@
+import { Tenant, rootTenantDto } from "../../../shared/Tenant.js";
+import { GetTenantByIdRepository, GetTenantByIdUseCase } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+class GetTenantByIdUseCase_GetTenantByIdUseCase {
+    constructor(repository){
+        this.repository = repository;
+    }
+    async execute(id) {
+        if ("root" === id) return Result.ok(Tenant.from(rootTenantDto));
+        const result = await this.repository.execute(id);
+        if (result.isFail()) return Result.fail(result.error);
+        return Result.ok(result.value);
+    }
+}
+const GetTenantById_GetTenantByIdUseCase = GetTenantByIdUseCase.createImplementation({
+    implementation: GetTenantByIdUseCase_GetTenantByIdUseCase,
+    dependencies: [
+        GetTenantByIdRepository
+    ]
+});
+export default GetTenantById_GetTenantByIdUseCase;
+
+//# sourceMappingURL=GetTenantByIdUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetTenantById/GetTenantByIdUseCase.js","sources":["../../../../src/api/features/GetTenantById/GetTenantByIdUseCase.ts"],"sourcesContent":["import { Tenant, rootTenantDto } from \"~/shared/Tenant.js\";\nimport {\n    GetTenantByIdUseCase as UseCaseAbstraction,\n    GetTenantByIdRepository\n} from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\n\nclass GetTenantByIdUseCase implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetTenantByIdRepository.Interface) {}\n\n    async execute(id: string): Promise<Result<Tenant, UseCaseAbstraction.Error>> {\n        // Handle special root tenant case\n        if (id === \"root\") {\n            return Result.ok(Tenant.from(rootTenantDto));\n        }\n\n        // Delegate to repository\n        const result = await this.repository.execute(id);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport default UseCaseAbstraction.createImplementation({\n    implementation: GetTenantByIdUseCase,\n    dependencies: [GetTenantByIdRepository]\n});\n"],"names":["GetTenantByIdUseCase","repository","id","Result","Tenant","rootTenantDto","result","UseCaseAbstraction","GetTenantByIdRepository"],"mappings":";;;AAOA,MAAMA;IACF,YAAoBC,UAA6C,CAAE;aAA/CA,UAAU,GAAVA;IAAgD;IAEpE,MAAM,QAAQC,EAAU,EAAqD;QAEzE,IAAIA,AAAO,WAAPA,IACA,OAAOC,OAAO,EAAE,CAACC,OAAO,IAAI,CAACC;QAIjC,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACJ;QAC7C,IAAII,OAAO,MAAM,IACb,OAAOH,OAAO,IAAI,CAACG,OAAO,KAAK;QAGnC,OAAOH,OAAO,EAAE,CAACG,OAAO,KAAK;IACjC;AACJ;AAEA,2CAAeC,qBAAAA,oBAAuC,CAAC;IACnD,gBAAgBP;IAChB,cAAc;QAACQ;KAAwB;AAC3C"}

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

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import type { Tenant } from "../../../shared/Tenant.js";
+import { TenantModelNotFoundError, type TenantNotFoundError, type TenantPersistenceError } from "../../domain/errors.js";
+/**
+ * GetTenantById Use Case
+ */
+export interface IGetTenantByIdUseCase {
+    execute(id: string): Promise<Result<Tenant, UseCaseError>>;
+}
+export interface IGetTenantByIdUseCaseErrors {
+    notFound: TenantNotFoundError;
+    persistence: TenantPersistenceError;
+    modelNotFoundError: TenantModelNotFoundError;
+}
+type UseCaseError = IGetTenantByIdUseCaseErrors[keyof IGetTenantByIdUseCaseErrors];
+export declare const GetTenantByIdUseCase: import("@webiny/di").Abstraction<IGetTenantByIdUseCase>;
+export declare namespace GetTenantByIdUseCase {
+    type Interface = IGetTenantByIdUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * GetTenantByIdRepository - Retrieves a tenant from storage.
+ */
+export interface IGetTenantByIdRepository {
+    execute(id: string): Promise<Result<Tenant, RepositoryError>>;
+}
+export interface IGetTenantByIdRepositoryErrors {
+    notFound: TenantNotFoundError;
+    persistence: TenantPersistenceError;
+    modelNotFoundError: TenantModelNotFoundError;
+}
+type RepositoryError = IGetTenantByIdRepositoryErrors[keyof IGetTenantByIdRepositoryErrors];
+export declare const GetTenantByIdRepository: import("@webiny/di").Abstraction<IGetTenantByIdRepository>;
+export declare namespace GetTenantByIdRepository {
+    type Interface = IGetTenantByIdRepository;
+    type Error = RepositoryError;
+}
+export {};

package/api/features/GetTenantById/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetTenantById/abstractions.js","sources":["../../../../src/api/features/GetTenantById/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { Tenant } from \"../../../shared/Tenant.js\";\nimport {\n    TenantModelNotFoundError,\n    type TenantNotFoundError,\n    type TenantPersistenceError\n} from \"../../domain/errors.js\";\n\n/**\n * GetTenantById Use Case\n */\nexport interface IGetTenantByIdUseCase {\n    execute(id: string): Promise<Result<Tenant, UseCaseError>>;\n}\n\nexport interface IGetTenantByIdUseCaseErrors {\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n}\n\ntype UseCaseError = IGetTenantByIdUseCaseErrors[keyof IGetTenantByIdUseCaseErrors];\n\nexport const GetTenantByIdUseCase = createAbstraction<IGetTenantByIdUseCase>(\n    \"TenantManager/GetTenantByIdUseCase\"\n);\n\nexport namespace GetTenantByIdUseCase {\n    export type Interface = IGetTenantByIdUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * GetTenantByIdRepository - Retrieves a tenant from storage.\n */\nexport interface IGetTenantByIdRepository {\n    execute(id: string): Promise<Result<Tenant, RepositoryError>>;\n}\n\nexport interface IGetTenantByIdRepositoryErrors {\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n}\n\ntype RepositoryError = IGetTenantByIdRepositoryErrors[keyof IGetTenantByIdRepositoryErrors];\n\nexport const GetTenantByIdRepository = createAbstraction<IGetTenantByIdRepository>(\n    \"TenantManager/GetTenantByIdRepository\"\n);\n\nexport namespace GetTenantByIdRepository {\n    export type Interface = IGetTenantByIdRepository;\n    export type Error = RepositoryError;\n}\n"],"names":["GetTenantByIdUseCase","createAbstraction","GetTenantByIdRepository"],"mappings":";AAwBO,MAAMA,uBAAuBC,kBAChC;AAuBG,MAAMC,0BAA0BD,kBACnC"}

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

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

package/api/features/GetTenantById/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/GetTenantById/feature.js","sources":["../../../../src/api/features/GetTenantById/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport GetTenantByIdUseCase from \"./GetTenantByIdUseCase.js\";\nimport GetTenantByIdRepository from \"./GetTenantByIdRepository.js\";\n\nexport const GetTenantByIdFeature = createFeature({\n    name: \"GetTenantById\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(GetTenantByIdUseCase);\n\n        // Register repository (singleton scope)\n        container.register(GetTenantByIdRepository).inSingletonScope();\n    }\n});\n"],"names":["GetTenantByIdFeature","createFeature","container","GetTenantByIdUseCase","GetTenantByIdRepository"],"mappings":";;;AAIO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QAEdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;IAChE;AACJ"}

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

@@ -0,0 +1,17 @@
+import { Tenant } from "../../../shared/Tenant.js";
+import { UpdateTenantRepository as RepositoryAbstraction, UpdateTenantInput } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { GetEntryUseCase } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/exports/api/cms/model";
+declare class UpdateTenantRepository implements RepositoryAbstraction.Interface {
+    private getModelUseCase;
+    private getEntryUseCase;
+    private updateEntryUseCase;
+    constructor(getModelUseCase: GetModelUseCase.Interface, getEntryUseCase: GetEntryUseCase.Interface, updateEntryUseCase: UpdateEntryUseCase.Interface);
+    execute(id: string, input: UpdateTenantInput): Promise<Result<Tenant, RepositoryAbstraction.Error>>;
+}
+declare const _default: typeof UpdateTenantRepository & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateTenantRepository>;
+};
+export default _default;

package/api/features/UpdateTenant/UpdateTenantRepository.js

@@ -0,0 +1,51 @@
+import { Tenant } from "../../../shared/Tenant.js";
+import { TENANT_MODEL_ID } from "../../../shared/constants.js";
+import { TenantNotFoundError, TenantPersistenceError } from "../../domain/errors.js";
+import { UpdateTenantRepository } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { EntryId, GetEntryUseCase, UpdateEntryUseCase } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/exports/api/cms/model";
+class UpdateTenantRepository_UpdateTenantRepository {
+    constructor(getModelUseCase, getEntryUseCase, updateEntryUseCase){
+        this.getModelUseCase = getModelUseCase;
+        this.getEntryUseCase = getEntryUseCase;
+        this.updateEntryUseCase = updateEntryUseCase;
+    }
+    async execute(id, input) {
+        try {
+            const entryId = EntryId.from(id);
+            const modelResult = await this.getModelUseCase.execute(TENANT_MODEL_ID);
+            if (modelResult.isFail()) return Result.fail(new TenantPersistenceError(new Error(`Model "${TENANT_MODEL_ID}" was not found!`)));
+            const getEntryResult = await this.getEntryUseCase.execute(modelResult.value, {
+                where: {
+                    entryId: entryId.id,
+                    latest: true
+                }
+            });
+            if (getEntryResult.isFail()) return Result.fail(new TenantNotFoundError(id));
+            const updateResult = await this.updateEntryUseCase.execute(modelResult.value, entryId.toString(), {
+                values: input
+            });
+            if (updateResult.isFail()) return Result.fail(new TenantPersistenceError(updateResult.error));
+            const updatedEntry = updateResult.value;
+            const tenantDto = {
+                id: updatedEntry.entryId,
+                values: updatedEntry.values
+            };
+            return Result.ok(Tenant.from(tenantDto));
+        } catch (error) {
+            return Result.fail(new TenantPersistenceError(error));
+        }
+    }
+}
+const UpdateTenant_UpdateTenantRepository = UpdateTenantRepository.createImplementation({
+    implementation: UpdateTenantRepository_UpdateTenantRepository,
+    dependencies: [
+        GetModelUseCase,
+        GetEntryUseCase,
+        UpdateEntryUseCase
+    ]
+});
+export default UpdateTenant_UpdateTenantRepository;
+
+//# sourceMappingURL=UpdateTenantRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/UpdateTenant/UpdateTenantRepository.js","sources":["../../../../src/api/features/UpdateTenant/UpdateTenantRepository.ts"],"sourcesContent":["import { Tenant, TenantDto, TenantValues } from \"~/shared/Tenant.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\nimport { TenantNotFoundError, TenantPersistenceError } from \"../../domain/errors.js\";\nimport {\n    UpdateTenantRepository as RepositoryAbstraction,\n    UpdateTenantInput\n} from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { GetEntryUseCase } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/exports/api/cms/model\";\n\nclass UpdateTenantRepository implements RepositoryAbstraction.Interface {\n    constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryUseCase: GetEntryUseCase.Interface,\n        private updateEntryUseCase: UpdateEntryUseCase.Interface\n    ) {}\n\n    async execute(\n        id: string,\n        input: UpdateTenantInput\n    ): Promise<Result<Tenant, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = EntryId.from(id);\n\n            // Get the tenant model\n            const modelResult = await this.getModelUseCase.execute(TENANT_MODEL_ID);\n            if (modelResult.isFail()) {\n                return Result.fail(\n                    new TenantPersistenceError(\n                        new Error(`Model \"${TENANT_MODEL_ID}\" was not found!`)\n                    )\n                );\n            }\n\n            // Get the current tenant entry to verify it exists\n            const getEntryResult = await this.getEntryUseCase.execute<TenantValues>(\n                modelResult.value,\n                {\n                    where: { entryId: entryId.id, latest: true }\n                }\n            );\n\n            if (getEntryResult.isFail()) {\n                return Result.fail(new TenantNotFoundError(id));\n            }\n\n            const updateResult = await this.updateEntryUseCase.execute(\n                modelResult.value,\n                entryId.toString(),\n                {\n                    values: input\n                }\n            );\n\n            if (updateResult.isFail()) {\n                return Result.fail(new TenantPersistenceError(updateResult.error));\n            }\n\n            const updatedEntry = updateResult.value;\n\n            const tenantDto: TenantDto = {\n                id: updatedEntry.entryId,\n                values: updatedEntry.values as TenantValues\n            };\n\n            return Result.ok(Tenant.from(tenantDto));\n        } catch (error) {\n            return Result.fail(new TenantPersistenceError(error));\n        }\n    }\n}\n\nexport default RepositoryAbstraction.createImplementation({\n    implementation: UpdateTenantRepository,\n    dependencies: [GetModelUseCase, GetEntryUseCase, UpdateEntryUseCase]\n});\n"],"names":["UpdateTenantRepository","getModelUseCase","getEntryUseCase","updateEntryUseCase","id","input","entryId","EntryId","modelResult","TENANT_MODEL_ID","Result","TenantPersistenceError","Error","getEntryResult","TenantNotFoundError","updateResult","updatedEntry","tenantDto","Tenant","error","RepositoryAbstraction","GetModelUseCase","GetEntryUseCase","UpdateEntryUseCase"],"mappings":";;;;;;;AAaA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,eAA0C,EAC1CC,kBAAgD,CAC1D;aAHUF,eAAe,GAAfA;aACAC,eAAe,GAAfA;aACAC,kBAAkB,GAAlBA;IACT;IAEH,MAAM,QACFC,EAAU,EACVC,KAAwB,EAC4B;QACpD,IAAI;YACA,MAAMC,UAAUC,QAAQ,IAAI,CAACH;YAG7B,MAAMI,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACC;YACvD,IAAID,YAAY,MAAM,IAClB,OAAOE,OAAO,IAAI,CACd,IAAIC,uBACA,IAAIC,MAAM,CAAC,OAAO,EAAEH,gBAAgB,gBAAgB,CAAC;YAMjE,MAAMI,iBAAiB,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CACrDL,YAAY,KAAK,EACjB;gBACI,OAAO;oBAAE,SAASF,QAAQ,EAAE;oBAAE,QAAQ;gBAAK;YAC/C;YAGJ,IAAIO,eAAe,MAAM,IACrB,OAAOH,OAAO,IAAI,CAAC,IAAII,oBAAoBV;YAG/C,MAAMW,eAAe,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CACtDP,YAAY,KAAK,EACjBF,QAAQ,QAAQ,IAChB;gBACI,QAAQD;YACZ;YAGJ,IAAIU,aAAa,MAAM,IACnB,OAAOL,OAAO,IAAI,CAAC,IAAIC,uBAAuBI,aAAa,KAAK;YAGpE,MAAMC,eAAeD,aAAa,KAAK;YAEvC,MAAME,YAAuB;gBACzB,IAAID,aAAa,OAAO;gBACxB,QAAQA,aAAa,MAAM;YAC/B;YAEA,OAAON,OAAO,EAAE,CAACQ,OAAO,IAAI,CAACD;QACjC,EAAE,OAAOE,OAAO;YACZ,OAAOT,OAAO,IAAI,CAAC,IAAIC,uBAAuBQ;QAClD;IACJ;AACJ;AAEA,4CAAeC,uBAAAA,oBAA0C,CAAC;IACtD,gBAAgBpB;IAChB,cAAc;QAACqB;QAAiBC;QAAiBC;KAAmB;AACxE"}

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

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { Tenant } from "../../../shared/Tenant.js";
+import { UpdateTenantUseCase as UseCaseAbstraction, UpdateTenantRepository, UpdateTenantInput } from "./abstractions.js";
+declare class UpdateTenantUseCase implements UseCaseAbstraction.Interface {
+    private repository;
+    constructor(repository: UpdateTenantRepository.Interface);
+    execute(id: string, input: UpdateTenantInput): Promise<Result<Tenant, UseCaseAbstraction.Error>>;
+}
+declare const _default: typeof UpdateTenantUseCase & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateTenantUseCase>;
+};
+export default _default;