@webiny/tenant-manager 0.0.0-unstable.61c048f412

package/api/features/CreateTenant/CreateTenantRepository.js

@@ -0,0 +1,48 @@
+import { TenantCreationError, TenantModelNotFoundError } from "../../domain/errors.js";
+import { CreateTenantRepository as RepositoryAbstraction } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/exports/api/cms/model";
+import { TENANT_MODEL_ID } from "../../../shared/constants.js";
+class CreateTenantRepository {
+  constructor(getModelUseCase, createEntryUseCase) {
+    this.getModelUseCase = getModelUseCase;
+    this.createEntryUseCase = createEntryUseCase;
+  }
+  async execute(tenant) {
+    try {
+      // Get the tenant model
+      const modelResult = await this.getModelUseCase.execute(TENANT_MODEL_ID);
+      if (modelResult.isFail()) {
+        return Result.fail(new TenantModelNotFoundError());
+      }
+
+      // Prepare tenant values with default isInstalled: false
+      const tenantValues = {
+        name: tenant.values.name,
+        status: tenant.values.status,
+        description: tenant.values.description,
+        isInstalled: false,
+        extensions: tenant.values.extensions || {}
+      };
+
+      // Create the tenant entry
+      const createResult = await this.createEntryUseCase.execute(modelResult.value, {
+        id: tenant.id,
+        values: tenantValues
+      });
+      if (createResult.isFail()) {
+        return Result.fail(new TenantCreationError(createResult.error));
+      }
+      return Result.ok(tenant);
+    } catch (error) {
+      return Result.fail(new TenantCreationError(error));
+    }
+  }
+}
+export default RepositoryAbstraction.createImplementation({
+  implementation: CreateTenantRepository,
+  dependencies: [GetModelUseCase, CreateEntryUseCase]
+});
+
+//# sourceMappingURL=CreateTenantRepository.js.map

package/api/features/CreateTenant/CreateTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TenantCreationError","TenantModelNotFoundError","CreateTenantRepository","RepositoryAbstraction","Result","CreateEntryUseCase","GetModelUseCase","TENANT_MODEL_ID","constructor","getModelUseCase","createEntryUseCase","execute","tenant","modelResult","isFail","fail","tenantValues","name","values","status","description","isInstalled","extensions","createResult","value","id","error","ok","createImplementation","implementation","dependencies"],"sources":["CreateTenantRepository.ts"],"sourcesContent":["import { Tenant, TenantValues } from \"~/shared/Tenant.js\";\nimport { TenantCreationError, TenantModelNotFoundError } from \"../../domain/errors.js\";\nimport { CreateTenantRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/exports/api/cms/model\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\n\nclass CreateTenantRepository implements RepositoryAbstraction.Interface {\n    constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private createEntryUseCase: CreateEntryUseCase.Interface\n    ) {}\n\n    async execute(tenant: Tenant): Promise<Result<Tenant, RepositoryAbstraction.Error>> {\n        try {\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            // Prepare tenant values with default isInstalled: false\n            const tenantValues: TenantValues = {\n                name: tenant.values.name,\n                status: tenant.values.status,\n                description: tenant.values.description,\n                isInstalled: false,\n                extensions: tenant.values.extensions || {}\n            };\n\n            // Create the tenant entry\n            const createResult = await this.createEntryUseCase.execute(modelResult.value, {\n                id: tenant.id,\n                values: tenantValues\n            });\n\n            if (createResult.isFail()) {\n                return Result.fail(new TenantCreationError(createResult.error));\n            }\n\n            return Result.ok(tenant);\n        } catch (error) {\n            return Result.fail(new TenantCreationError(error as Error));\n        }\n    }\n}\n\nexport default RepositoryAbstraction.createImplementation({\n    implementation: CreateTenantRepository,\n    dependencies: [GetModelUseCase, CreateEntryUseCase]\n});\n"],"mappings":"AACA,SAASA,mBAAmB,EAAEC,wBAAwB;AACtD,SAASC,sBAAsB,IAAIC,qBAAqB;AACxD,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,QAAQ,mDAAmD;AACtF,SAASC,eAAe,QAAQ,gDAAgD;AAChF,SAASC,eAAe;AAExB,MAAML,sBAAsB,CAA4C;EACpEM,WAAWA,CACCC,eAA0C,EAC1CC,kBAAgD,EAC1D;IAAA,KAFUD,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,kBAAgD,GAAhDA,kBAAgD;EACzD;EAEH,MAAMC,OAAOA,CAACC,MAAc,EAAwD;IAChF,IAAI;MACA;MACA,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACJ,eAAe,CAACE,OAAO,CAACJ,eAAe,CAAC;MACvE,IAAIM,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;QACtB,OAAOV,MAAM,CAACW,IAAI,CAAC,IAAId,wBAAwB,CAAC,CAAC,CAAC;MACtD;;MAEA;MACA,MAAMe,YAA0B,GAAG;QAC/BC,IAAI,EAAEL,MAAM,CAACM,MAAM,CAACD,IAAI;QACxBE,MAAM,EAAEP,MAAM,CAACM,MAAM,CAACC,MAAM;QAC5BC,WAAW,EAAER,MAAM,CAACM,MAAM,CAACE,WAAW;QACtCC,WAAW,EAAE,KAAK;QAClBC,UAAU,EAAEV,MAAM,CAACM,MAAM,CAACI,UAAU,IAAI,CAAC;MAC7C,CAAC;;MAED;MACA,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACb,kBAAkB,CAACC,OAAO,CAACE,WAAW,CAACW,KAAK,EAAE;QAC1EC,EAAE,EAAEb,MAAM,CAACa,EAAE;QACbP,MAAM,EAAEF;MACZ,CAAC,CAAC;MAEF,IAAIO,YAAY,CAACT,MAAM,CAAC,CAAC,EAAE;QACvB,OAAOV,MAAM,CAACW,IAAI,CAAC,IAAIf,mBAAmB,CAACuB,YAAY,CAACG,KAAK,CAAC,CAAC;MACnE;MAEA,OAAOtB,MAAM,CAACuB,EAAE,CAACf,MAAM,CAAC;IAC5B,CAAC,CAAC,OAAOc,KAAK,EAAE;MACZ,OAAOtB,MAAM,CAACW,IAAI,CAAC,IAAIf,mBAAmB,CAAC0B,KAAc,CAAC,CAAC;IAC/D;EACJ;AACJ;AAEA,eAAevB,qBAAqB,CAACyB,oBAAoB,CAAC;EACtDC,cAAc,EAAE3B,sBAAsB;EACtC4B,YAAY,EAAE,CAACxB,eAAe,EAAED,kBAAkB;AACtD,CAAC,CAAC","ignoreList":[]}

package/api/features/CreateTenant/CreateTenantUseCase.d.ts

@@ -0,0 +1,14 @@
+import { CreateTenantUseCase as UseCaseAbstraction, ICreateTenantInput, CreateTenantRepository } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { Tenant } from "../../../shared/Tenant.js";
+declare class CreateTenantUseCase implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, repository: CreateTenantRepository.Interface);
+    execute(input: ICreateTenantInput): Promise<Result<Tenant, UseCaseAbstraction.Error>>;
+}
+declare const _default: typeof CreateTenantUseCase & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateTenantUseCase>;
+};
+export default _default;

package/api/features/CreateTenant/CreateTenantUseCase.js

@@ -0,0 +1,44 @@
+import { CreateTenantUseCase as UseCaseAbstraction, CreateTenantRepository } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { Tenant } from "../../../shared/Tenant.js";
+import { TenantId } from "../../domain/TenantId.js";
+class CreateTenantUseCase {
+  constructor(identityContext, repository) {
+    this.identityContext = identityContext;
+    this.repository = repository;
+  }
+  async execute(input) {
+    // Authorization checks
+    const identity = this.identityContext.getIdentity();
+    if (!identity.isAdmin() || !this.identityContext.getPermission("tm.tenant")) {
+      return Result.fail(new NotAuthorizedError({
+        message: "Not authorized to create tenants!"
+      }));
+    }
+    const tenant = Tenant.from({
+      id: TenantId.from(input.id),
+      values: {
+        name: input.name,
+        description: input.description || "(no description)",
+        extensions: input.extensions ?? {},
+        status: "disabled",
+        isInstalled: false
+      }
+    });
+
+    // Create the tenant
+    const result = await this.repository.execute(tenant);
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    return Result.ok(result.value);
+  }
+}
+export default UseCaseAbstraction.createImplementation({
+  implementation: CreateTenantUseCase,
+  dependencies: [IdentityContext, CreateTenantRepository]
+});
+
+//# sourceMappingURL=CreateTenantUseCase.js.map

package/api/features/CreateTenant/CreateTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CreateTenantUseCase","UseCaseAbstraction","CreateTenantRepository","Result","IdentityContext","NotAuthorizedError","Tenant","TenantId","constructor","identityContext","repository","execute","input","identity","getIdentity","isAdmin","getPermission","fail","message","tenant","from","id","values","name","description","extensions","status","isInstalled","result","isFail","error","ok","value","createImplementation","implementation","dependencies"],"sources":["CreateTenantUseCase.ts"],"sourcesContent":["import {\n    CreateTenantUseCase as UseCaseAbstraction,\n    ICreateTenantInput,\n    CreateTenantRepository\n} from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport { Tenant } from \"~/shared/Tenant.js\";\nimport { TenantId } from \"~/api/domain/TenantId.js\";\n\nclass CreateTenantUseCase implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private repository: CreateTenantRepository.Interface\n    ) {}\n\n    async execute(input: ICreateTenantInput): Promise<Result<Tenant, UseCaseAbstraction.Error>> {\n        // Authorization checks\n        const identity = this.identityContext.getIdentity();\n        if (!identity.isAdmin() || !this.identityContext.getPermission(\"tm.tenant\")) {\n            return Result.fail(\n                new NotAuthorizedError({\n                    message: \"Not authorized to create tenants!\"\n                })\n            );\n        }\n\n        const tenant = Tenant.from({\n            id: TenantId.from(input.id),\n            values: {\n                name: input.name,\n                description: input.description || \"(no description)\",\n                extensions: input.extensions ?? {},\n                status: \"disabled\",\n                isInstalled: false\n            }\n        });\n\n        // Create the tenant\n        const result = await this.repository.execute(tenant);\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: CreateTenantUseCase,\n    dependencies: [IdentityContext, CreateTenantRepository]\n});\n"],"mappings":"AAAA,SACIA,mBAAmB,IAAIC,kBAAkB,EAEzCC,sBAAsB;AAE1B,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,0CAA0C;AAC1E,SAASC,kBAAkB,QAAQ,qDAAqD;AACxF,SAASC,MAAM;AACf,SAASC,QAAQ;AAEjB,MAAMP,mBAAmB,CAAyC;EAC9DQ,WAAWA,CACCC,eAA0C,EAC1CC,UAA4C,EACtD;IAAA,KAFUD,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,UAA4C,GAA5CA,UAA4C;EACrD;EAEH,MAAMC,OAAOA,CAACC,KAAyB,EAAqD;IACxF;IACA,MAAMC,QAAQ,GAAG,IAAI,CAACJ,eAAe,CAACK,WAAW,CAAC,CAAC;IACnD,IAAI,CAACD,QAAQ,CAACE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAACN,eAAe,CAACO,aAAa,CAAC,WAAW,CAAC,EAAE;MACzE,OAAOb,MAAM,CAACc,IAAI,CACd,IAAIZ,kBAAkB,CAAC;QACnBa,OAAO,EAAE;MACb,CAAC,CACL,CAAC;IACL;IAEA,MAAMC,MAAM,GAAGb,MAAM,CAACc,IAAI,CAAC;MACvBC,EAAE,EAAEd,QAAQ,CAACa,IAAI,CAACR,KAAK,CAACS,EAAE,CAAC;MAC3BC,MAAM,EAAE;QACJC,IAAI,EAAEX,KAAK,CAACW,IAAI;QAChBC,WAAW,EAAEZ,KAAK,CAACY,WAAW,IAAI,kBAAkB;QACpDC,UAAU,EAAEb,KAAK,CAACa,UAAU,IAAI,CAAC,CAAC;QAClCC,MAAM,EAAE,UAAU;QAClBC,WAAW,EAAE;MACjB;IACJ,CAAC,CAAC;;IAEF;IACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAAClB,UAAU,CAACC,OAAO,CAACQ,MAAM,CAAC;IACpD,IAAIS,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAO1B,MAAM,CAACc,IAAI,CAACW,MAAM,CAACE,KAAK,CAAC;IACpC;IAEA,OAAO3B,MAAM,CAAC4B,EAAE,CAACH,MAAM,CAACI,KAAK,CAAC;EAClC;AACJ;AAEA,eAAe/B,kBAAkB,CAACgC,oBAAoB,CAAC;EACnDC,cAAc,EAAElC,mBAAmB;EACnCmC,YAAY,EAAE,CAAC/B,eAAe,EAAEF,sBAAsB;AAC1D,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,41 @@
+import { Result } from "@webiny/feature/api";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { TenantCreationError, TenantModelNotFoundError, type TenantPersistenceError } from "../../../api/domain/errors.js";
+import type { Tenant, TenantExtensions } from "../../../shared/Tenant.js";
+export interface ICreateTenantInput {
+    id?: string;
+    name: string;
+    description?: string;
+    extensions: TenantExtensions;
+}
+export interface ICreateTenantUseCaseErrors {
+    persistence: TenantPersistenceError;
+    modelNotFoundError: TenantModelNotFoundError;
+    notAuthorized: NotAuthorizedError;
+    tenantCreation: TenantCreationError;
+}
+export type ICreateTenantUseCaseError = ICreateTenantUseCaseErrors[keyof ICreateTenantUseCaseErrors];
+export interface ICreateTenantUseCase {
+    execute(input: ICreateTenantInput): Promise<Result<Tenant, ICreateTenantUseCaseError>>;
+}
+export declare const CreateTenantUseCase: import("@webiny/di").Abstraction<ICreateTenantUseCase>;
+export declare namespace CreateTenantUseCase {
+    type Interface = ICreateTenantUseCase;
+    type Input = ICreateTenantInput;
+    type Error = ICreateTenantUseCaseError;
+}
+export interface ICreateTenantRepositoryErrors {
+    persistence: TenantPersistenceError;
+    modelNotFoundError: TenantModelNotFoundError;
+    tenantCreation: TenantCreationError;
+}
+type IRepositoryError = ICreateTenantRepositoryErrors[keyof ICreateTenantRepositoryErrors];
+export interface ICreateTenantRepository {
+    execute(tenant: Tenant): Promise<Result<Tenant, IRepositoryError>>;
+}
+export declare const CreateTenantRepository: import("@webiny/di").Abstraction<ICreateTenantRepository>;
+export declare namespace CreateTenantRepository {
+    type Interface = ICreateTenantRepository;
+    type Error = IRepositoryError;
+}
+export {};

package/api/features/CreateTenant/abstractions.js

@@ -0,0 +1,11 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+// USE CASE
+
+export const CreateTenantUseCase = createAbstraction("TenantManager/CreateTenantUseCase");
+
+// REPOSITORY
+
+export const CreateTenantRepository = createAbstraction("TenantManager/CreateTenantRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CreateTenantUseCase","CreateTenantRepository"],"sources":["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    TenantCreationError,\n    TenantModelNotFoundError,\n    type TenantPersistenceError\n} from \"~/api/domain/errors.js\";\nimport type { Tenant, TenantExtensions } from \"~/shared/Tenant.js\";\n\n// USE CASE\n\nexport interface ICreateTenantInput {\n    id?: string;\n    name: string;\n    description?: string;\n    extensions: TenantExtensions;\n}\n\nexport interface ICreateTenantUseCaseErrors {\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n    notAuthorized: NotAuthorizedError;\n    tenantCreation: TenantCreationError;\n}\n\nexport type ICreateTenantUseCaseError =\n    ICreateTenantUseCaseErrors[keyof ICreateTenantUseCaseErrors];\n\nexport interface ICreateTenantUseCase {\n    execute(input: ICreateTenantInput): Promise<Result<Tenant, ICreateTenantUseCaseError>>;\n}\n\nexport const CreateTenantUseCase = createAbstraction<ICreateTenantUseCase>(\n    \"TenantManager/CreateTenantUseCase\"\n);\n\nexport namespace CreateTenantUseCase {\n    export type Interface = ICreateTenantUseCase;\n    export type Input = ICreateTenantInput;\n    export type Error = ICreateTenantUseCaseError;\n}\n\n// REPOSITORY\n\nexport interface ICreateTenantRepositoryErrors {\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n    tenantCreation: TenantCreationError;\n}\n\ntype IRepositoryError = ICreateTenantRepositoryErrors[keyof ICreateTenantRepositoryErrors];\n\nexport interface ICreateTenantRepository {\n    execute(tenant: Tenant): Promise<Result<Tenant, IRepositoryError>>;\n}\n\nexport const CreateTenantRepository = createAbstraction<ICreateTenantRepository>(\n    \"TenantManager/CreateTenantRepository\"\n);\n\nexport namespace CreateTenantRepository {\n    export type Interface = ICreateTenantRepository;\n    export type Error = IRepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAUvD;;AAuBA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAChD,mCACJ,CAAC;;AAQD;;AAcA,OAAO,MAAME,sBAAsB,GAAGF,iBAAiB,CACnD,sCACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const CreateTenantFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/api/features/CreateTenant/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import CreateTenantUseCase from "./CreateTenantUseCase.js";
+import CreateTenantRepository from "./CreateTenantRepository.js";
+export const CreateTenantFeature = createFeature({
+  name: "CreateTenant",
+  register(container) {
+    // Register use case (transient scope)
+    container.register(CreateTenantUseCase);
+
+    // Register repository (singleton scope)
+    container.register(CreateTenantRepository).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CreateTenantUseCase","CreateTenantRepository","CreateTenantFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport CreateTenantUseCase from \"./CreateTenantUseCase.js\";\nimport CreateTenantRepository from \"./CreateTenantRepository.js\";\n\nexport const CreateTenantFeature = createFeature({\n    name: \"CreateTenant\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(CreateTenantUseCase);\n\n        // Register repository (singleton scope)\n        container.register(CreateTenantRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,OAAOC,mBAAmB;AAC1B,OAAOC,sBAAsB;AAE7B,OAAO,MAAMC,mBAAmB,GAAGH,aAAa,CAAC;EAC7CI,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,mBAAmB,CAAC;;IAEvC;IACAK,SAAS,CAACD,QAAQ,CAACH,sBAAsB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACjE;AACJ,CAAC,CAAC","ignoreList":[]}

package/api/features/DeleteTenantOnEntryDelete/DeleteTenantOnEntryDeleteHandler.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js";
+import { DeleteTenantUseCase } from "@webiny/api-core/features/tenancy/DeleteTenant";
+declare class DeleteTenantOnEntryDeleteHandler implements EntryAfterDeleteEventHandler.Interface {
+    private deleteTenant;
+    constructor(deleteTenant: DeleteTenantUseCase.Interface);
+    handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
+}
+declare const _default: typeof DeleteTenantOnEntryDeleteHandler & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/EventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js").EntryAfterDeleteEvent>>;
+};
+export default _default;

package/api/features/DeleteTenantOnEntryDelete/DeleteTenantOnEntryDeleteHandler.js

@@ -0,0 +1,37 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js";
+import { DeleteTenantUseCase } from "@webiny/api-core/features/tenancy/DeleteTenant";
+import { TENANT_MODEL_ID } from "../../../shared/constants.js";
+class DeleteTenantOnEntryDeleteHandler {
+  constructor(deleteTenant) {
+    this.deleteTenant = deleteTenant;
+  }
+  async handle(event) {
+    const {
+      entry,
+      model
+    } = event.payload;
+
+    // Only handle tenant model deletions
+    if (model.modelId !== TENANT_MODEL_ID) {
+      return;
+    }
+
+    // Only handle permanent deletions
+    if (!event.payload.permanent) {
+      return;
+    }
+    try {
+      // Delete the tenant from api-core
+      await this.deleteTenant.execute(entry.entryId);
+    } catch (error) {
+      // Log error but don't throw - we don't want to prevent CMS deletion
+      console.error(`Failed to delete tenant ${entry.entryId}!`, error);
+    }
+  }
+}
+export default EntryAfterDeleteEventHandler.createImplementation({
+  implementation: DeleteTenantOnEntryDeleteHandler,
+  dependencies: [DeleteTenantUseCase]
+});
+
+//# sourceMappingURL=DeleteTenantOnEntryDeleteHandler.js.map

package/api/features/DeleteTenantOnEntryDelete/DeleteTenantOnEntryDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EntryAfterDeleteEventHandler","DeleteTenantUseCase","TENANT_MODEL_ID","DeleteTenantOnEntryDeleteHandler","constructor","deleteTenant","handle","event","entry","model","payload","modelId","permanent","execute","entryId","error","console","createImplementation","implementation","dependencies"],"sources":["DeleteTenantOnEntryDeleteHandler.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js\";\nimport { DeleteTenantUseCase } from \"@webiny/api-core/features/tenancy/DeleteTenant\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\n\nclass DeleteTenantOnEntryDeleteHandler implements EntryAfterDeleteEventHandler.Interface {\n    constructor(private deleteTenant: DeleteTenantUseCase.Interface) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { entry, model } = event.payload;\n\n        // Only handle tenant model deletions\n        if (model.modelId !== TENANT_MODEL_ID) {\n            return;\n        }\n\n        // Only handle permanent deletions\n        if (!event.payload.permanent) {\n            return;\n        }\n\n        try {\n            // Delete the tenant from api-core\n            await this.deleteTenant.execute(entry.entryId);\n        } catch (error) {\n            // Log error but don't throw - we don't want to prevent CMS deletion\n            console.error(`Failed to delete tenant ${entry.entryId}!`, error);\n        }\n    }\n}\n\nexport default EntryAfterDeleteEventHandler.createImplementation({\n    implementation: DeleteTenantOnEntryDeleteHandler,\n    dependencies: [DeleteTenantUseCase]\n});\n"],"mappings":"AAAA,SAASA,4BAA4B,QAAQ,sEAAsE;AACnH,SAASC,mBAAmB,QAAQ,gDAAgD;AACpF,SAASC,eAAe;AAExB,MAAMC,gCAAgC,CAAmD;EACrFC,WAAWA,CAASC,YAA2C,EAAE;IAAA,KAA7CA,YAA2C,GAA3CA,YAA2C;EAAG;EAElE,MAAMC,MAAMA,CAACC,KAAyC,EAAiB;IACnE,MAAM;MAAEC,KAAK;MAAEC;IAAM,CAAC,GAAGF,KAAK,CAACG,OAAO;;IAEtC;IACA,IAAID,KAAK,CAACE,OAAO,KAAKT,eAAe,EAAE;MACnC;IACJ;;IAEA;IACA,IAAI,CAACK,KAAK,CAACG,OAAO,CAACE,SAAS,EAAE;MAC1B;IACJ;IAEA,IAAI;MACA;MACA,MAAM,IAAI,CAACP,YAAY,CAACQ,OAAO,CAACL,KAAK,CAACM,OAAO,CAAC;IAClD,CAAC,CAAC,OAAOC,KAAK,EAAE;MACZ;MACAC,OAAO,CAACD,KAAK,CAAC,2BAA2BP,KAAK,CAACM,OAAO,GAAG,EAAEC,KAAK,CAAC;IACrE;EACJ;AACJ;AAEA,eAAef,4BAA4B,CAACiB,oBAAoB,CAAC;EAC7DC,cAAc,EAAEf,gCAAgC;EAChDgB,YAAY,EAAE,CAAClB,mBAAmB;AACtC,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const DeleteTenantOnEntryDeleteFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/api/features/DeleteTenantOnEntryDelete/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import DeleteTenantOnEntryDeleteHandler from "./DeleteTenantOnEntryDeleteHandler.js";
+export const DeleteTenantOnEntryDeleteFeature = createFeature({
+  name: "DeleteTenantOnEntryDelete",
+  register(container) {
+    // Register the event handler
+    container.register(DeleteTenantOnEntryDeleteHandler);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","DeleteTenantOnEntryDeleteHandler","DeleteTenantOnEntryDeleteFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport DeleteTenantOnEntryDeleteHandler from \"./DeleteTenantOnEntryDeleteHandler.js\";\n\nexport const DeleteTenantOnEntryDeleteFeature = createFeature({\n    name: \"DeleteTenantOnEntryDelete\",\n    register(container) {\n        // Register the event handler\n        container.register(DeleteTenantOnEntryDeleteHandler);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,OAAOC,gCAAgC;AAEvC,OAAO,MAAMC,gCAAgC,GAAGF,aAAa,CAAC;EAC1DG,IAAI,EAAE,2BAA2B;EACjCC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,gCAAgC,CAAC;EACxD;AACJ,CAAC,CAAC","ignoreList":[]}

package/api/features/DisableTenant/DisableTenantUseCase.d.ts

@@ -0,0 +1,20 @@
+import { DisableTenantUseCase as UseCaseAbstraction } 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";
+import { UpdateTenantUseCase as ApiCoreUpdateTenant } from "@webiny/api-core/features/tenancy/UpdateTenant";
+import { UpdateTenantUseCase as TenantManagerUpdateTenant } from "../UpdateTenant/abstractions.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+declare class DisableTenantUseCase implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private eventPublisher;
+    private coreUpdateTenant;
+    private tmUpdateTenant;
+    private tmGetTenantById;
+    constructor(identityContext: IdentityContext.Interface, eventPublisher: EventPublisher.Interface, coreUpdateTenant: ApiCoreUpdateTenant.Interface, tmUpdateTenant: TenantManagerUpdateTenant.Interface, tmGetTenantById: GetTenantByIdUseCase.Interface);
+    execute(tenantId: string): Promise<Result<void, UseCaseAbstraction.Error>>;
+}
+declare const _default: typeof DisableTenantUseCase & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDisableTenantUseCase>;
+};
+export default _default;

package/api/features/DisableTenant/DisableTenantUseCase.js

@@ -0,0 +1,66 @@
+import { DisableTenantUseCase as UseCaseAbstraction } 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";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { UpdateTenantUseCase as ApiCoreUpdateTenant } from "@webiny/api-core/features/tenancy/UpdateTenant";
+import { UpdateTenantUseCase as TenantManagerUpdateTenant } from "../UpdateTenant/abstractions.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+import { TenantBeforeDisableEvent, TenantAfterDisableEvent } from "./events.js";
+import { TenantPersistenceError } from "../../domain/errors.js";
+class DisableTenantUseCase {
+  constructor(identityContext, eventPublisher, coreUpdateTenant, tmUpdateTenant, tmGetTenantById) {
+    this.identityContext = identityContext;
+    this.eventPublisher = eventPublisher;
+    this.coreUpdateTenant = coreUpdateTenant;
+    this.tmUpdateTenant = tmUpdateTenant;
+    this.tmGetTenantById = tmGetTenantById;
+  }
+  async execute(tenantId) {
+    // Authorization checks
+    const identity = this.identityContext.getIdentity();
+    if (!identity.isAdmin() || !this.identityContext.getPermission("tm.tenant")) {
+      return Result.fail(new NotAuthorizedError());
+    }
+
+    // Get current tenant to verify it exists
+    const getTenantResult = await this.tmGetTenantById.execute(tenantId);
+    if (getTenantResult.isFail()) {
+      return Result.fail(getTenantResult.error);
+    }
+    const tenant = getTenantResult.value;
+
+    // Publish before event
+    await this.eventPublisher.publish(new TenantBeforeDisableEvent({
+      tenant
+    }));
+
+    // Update api-core tenant first
+    const apiCoreResult = await this.coreUpdateTenant.execute(tenantId, {
+      status: "disabled"
+    });
+    if (apiCoreResult.isFail()) {
+      return Result.fail(new TenantPersistenceError(new Error(`Failed to update api-core tenant: ${apiCoreResult.error}`)));
+    }
+
+    // Update tenant-manager CMS entry
+    const updateResult = await this.tmUpdateTenant.execute(tenantId, {
+      status: "disabled"
+    });
+    if (updateResult.isFail()) {
+      return Result.fail(updateResult.error);
+    }
+
+    // Publish after event
+    await this.eventPublisher.publish(new TenantAfterDisableEvent({
+      tenant: updateResult.value
+    }));
+    return Result.ok();
+  }
+}
+export default UseCaseAbstraction.createImplementation({
+  implementation: DisableTenantUseCase,
+  dependencies: [IdentityContext, EventPublisher, ApiCoreUpdateTenant, TenantManagerUpdateTenant, GetTenantByIdUseCase]
+});
+
+//# sourceMappingURL=DisableTenantUseCase.js.map

package/api/features/DisableTenant/DisableTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DisableTenantUseCase","UseCaseAbstraction","Result","IdentityContext","EventPublisher","NotAuthorizedError","UpdateTenantUseCase","ApiCoreUpdateTenant","TenantManagerUpdateTenant","GetTenantByIdUseCase","TenantBeforeDisableEvent","TenantAfterDisableEvent","TenantPersistenceError","constructor","identityContext","eventPublisher","coreUpdateTenant","tmUpdateTenant","tmGetTenantById","execute","tenantId","identity","getIdentity","isAdmin","getPermission","fail","getTenantResult","isFail","error","tenant","value","publish","apiCoreResult","status","Error","updateResult","ok","createImplementation","implementation","dependencies"],"sources":["DisableTenantUseCase.ts"],"sourcesContent":["import { DisableTenantUseCase 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\";\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 { TenantBeforeDisableEvent, TenantAfterDisableEvent } from \"./events.js\";\nimport { TenantPersistenceError } from \"../../domain/errors.js\";\n\nclass DisableTenantUseCase 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        const identity = this.identityContext.getIdentity();\n        if (!identity.isAdmin() || !this.identityContext.getPermission(\"tm.tenant\")) {\n            return Result.fail(new NotAuthorizedError());\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 TenantBeforeDisableEvent({ tenant }));\n\n        // Update api-core tenant first\n        const apiCoreResult = await this.coreUpdateTenant.execute(tenantId, {\n            status: \"disabled\"\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 updateResult = await this.tmUpdateTenant.execute(tenantId, {\n            status: \"disabled\"\n        });\n\n        if (updateResult.isFail()) {\n            return Result.fail(updateResult.error);\n        }\n\n        // Publish after event\n        await this.eventPublisher.publish(\n            new TenantAfterDisableEvent({ tenant: updateResult.value })\n        );\n\n        return Result.ok();\n    }\n}\n\nexport default UseCaseAbstraction.createImplementation({\n    implementation: DisableTenantUseCase,\n    dependencies: [\n        IdentityContext,\n        EventPublisher,\n        ApiCoreUpdateTenant,\n        TenantManagerUpdateTenant,\n        GetTenantByIdUseCase\n    ]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,IAAIC,kBAAkB;AACnD,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,0CAA0C;AAC1E,SAASC,cAAc,QAAQ,0CAA0C;AACzE,SAASC,kBAAkB,QAAQ,qDAAqD;AACxF,SAASC,mBAAmB,IAAIC,mBAAmB,QAAQ,gDAAgD;AAC3G,SAASD,mBAAmB,IAAIE,yBAAyB;AACzD,SAASC,oBAAoB;AAC7B,SAASC,wBAAwB,EAAEC,uBAAuB;AAC1D,SAASC,sBAAsB;AAE/B,MAAMZ,oBAAoB,CAAyC;EAC/Da,WAAWA,CACCC,eAA0C,EAC1CC,cAAwC,EACxCC,gBAA+C,EAC/CC,cAAmD,EACnDC,eAA+C,EACzD;IAAA,KALUJ,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,gBAA+C,GAA/CA,gBAA+C;IAAA,KAC/CC,cAAmD,GAAnDA,cAAmD;IAAA,KACnDC,eAA+C,GAA/CA,eAA+C;EACxD;EAEH,MAAMC,OAAOA,CAACC,QAAgB,EAAmD;IAC7E;IACA,MAAMC,QAAQ,GAAG,IAAI,CAACP,eAAe,CAACQ,WAAW,CAAC,CAAC;IACnD,IAAI,CAACD,QAAQ,CAACE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAACT,eAAe,CAACU,aAAa,CAAC,WAAW,CAAC,EAAE;MACzE,OAAOtB,MAAM,CAACuB,IAAI,CAAC,IAAIpB,kBAAkB,CAAC,CAAC,CAAC;IAChD;;IAEA;IACA,MAAMqB,eAAe,GAAG,MAAM,IAAI,CAACR,eAAe,CAACC,OAAO,CAACC,QAAQ,CAAC;IACpE,IAAIM,eAAe,CAACC,MAAM,CAAC,CAAC,EAAE;MAC1B,OAAOzB,MAAM,CAACuB,IAAI,CAACC,eAAe,CAACE,KAAK,CAAC;IAC7C;IAEA,MAAMC,MAAM,GAAGH,eAAe,CAACI,KAAK;;IAEpC;IACA,MAAM,IAAI,CAACf,cAAc,CAACgB,OAAO,CAAC,IAAIrB,wBAAwB,CAAC;MAAEmB;IAAO,CAAC,CAAC,CAAC;;IAE3E;IACA,MAAMG,aAAa,GAAG,MAAM,IAAI,CAAChB,gBAAgB,CAACG,OAAO,CAACC,QAAQ,EAAE;MAChEa,MAAM,EAAE;IACZ,CAAC,CAAC;IACF,IAAID,aAAa,CAACL,MAAM,CAAC,CAAC,EAAE;MACxB,OAAOzB,MAAM,CAACuB,IAAI,CACd,IAAIb,sBAAsB,CACtB,IAAIsB,KAAK,CAAC,qCAAqCF,aAAa,CAACJ,KAAK,EAAE,CACxE,CACJ,CAAC;IACL;;IAEA;IACA,MAAMO,YAAY,GAAG,MAAM,IAAI,CAAClB,cAAc,CAACE,OAAO,CAACC,QAAQ,EAAE;MAC7Da,MAAM,EAAE;IACZ,CAAC,CAAC;IAEF,IAAIE,YAAY,CAACR,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOzB,MAAM,CAACuB,IAAI,CAACU,YAAY,CAACP,KAAK,CAAC;IAC1C;;IAEA;IACA,MAAM,IAAI,CAACb,cAAc,CAACgB,OAAO,CAC7B,IAAIpB,uBAAuB,CAAC;MAAEkB,MAAM,EAAEM,YAAY,CAACL;IAAM,CAAC,CAC9D,CAAC;IAED,OAAO5B,MAAM,CAACkC,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,eAAenC,kBAAkB,CAACoC,oBAAoB,CAAC;EACnDC,cAAc,EAAEtC,oBAAoB;EACpCuC,YAAY,EAAE,CACVpC,eAAe,EACfC,cAAc,EACdG,mBAAmB,EACnBC,yBAAyB,EACzBC,oBAAoB;AAE5B,CAAC,CAAC","ignoreList":[]}

package/api/features/DisableTenant/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 IDisableTenantUseCase {
+    execute(tenantId: string): Promise<Result<void, DisableTenantUseCase.Error>>;
+}
+export interface IDisableTenantUseCaseErrors {
+    notAuthorized: NotAuthorizedError;
+    notFound: TenantNotFoundError;
+    persistence: TenantPersistenceError;
+    modelNotFound: TenantModelNotFoundError;
+}
+type UseCaseError = IDisableTenantUseCaseErrors[keyof IDisableTenantUseCaseErrors];
+export declare const DisableTenantUseCase: import("@webiny/di").Abstraction<IDisableTenantUseCase>;
+export declare namespace DisableTenantUseCase {
+    type Interface = IDisableTenantUseCase;
+    type Error = UseCaseError;
+}
+export {};

package/api/features/DisableTenant/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DisableTenantUseCase"],"sources":["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 IDisableTenantUseCase {\n    execute(tenantId: string): Promise<Result<void, DisableTenantUseCase.Error>>;\n}\n\nexport interface IDisableTenantUseCaseErrors {\n    notAuthorized: NotAuthorizedError;\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n    modelNotFound: TenantModelNotFoundError;\n}\n\ntype UseCaseError = IDisableTenantUseCaseErrors[keyof IDisableTenantUseCaseErrors];\n\nexport const DisableTenantUseCase = createAbstraction<IDisableTenantUseCase>(\n    \"TenantManager/DisableTenantUseCase\"\n);\n\nexport namespace DisableTenantUseCase {\n    export type Interface = IDisableTenantUseCase;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAsBvD,OAAO,MAAMC,oBAAoB,GAAGD,iBAAiB,CACjD,oCACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,27 @@
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import type { Tenant } from "../../../shared/Tenant.js";
+export interface TenantBeforeDisablePayload {
+    tenant: Tenant;
+}
+export interface TenantAfterDisablePayload {
+    tenant: Tenant;
+}
+export declare class TenantBeforeDisableEvent extends DomainEvent<TenantBeforeDisablePayload> {
+    eventType: "tenant.beforeDisable";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<TenantBeforeDisableEvent>>;
+}
+export declare const TenantBeforeDisableEventHandler: import("@webiny/di").Abstraction<IEventHandler<TenantBeforeDisableEvent>>;
+export declare namespace TenantBeforeDisableEventHandler {
+    type Interface = IEventHandler<TenantBeforeDisableEvent>;
+    type Event = TenantBeforeDisableEvent;
+}
+export declare class TenantAfterDisableEvent extends DomainEvent<TenantAfterDisablePayload> {
+    eventType: "tenant.afterDisable";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<TenantAfterDisableEvent>>;
+}
+export declare const TenantAfterDisableEventHandler: import("@webiny/di").Abstraction<IEventHandler<TenantAfterDisableEvent>>;
+export declare namespace TenantAfterDisableEventHandler {
+    type Interface = IEventHandler<TenantAfterDisableEvent>;
+    type Event = TenantAfterDisableEvent;
+}

package/api/features/DisableTenant/events.js

@@ -0,0 +1,18 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+export class TenantBeforeDisableEvent extends DomainEvent {
+  eventType = "tenant.beforeDisable";
+  getHandlerAbstraction() {
+    return TenantBeforeDisableEventHandler;
+  }
+}
+export const TenantBeforeDisableEventHandler = createAbstraction("TenantManager/TenantBeforeDisableEventHandler");
+export class TenantAfterDisableEvent extends DomainEvent {
+  eventType = "tenant.afterDisable";
+  getHandlerAbstraction() {
+    return TenantAfterDisableEventHandler;
+  }
+}
+export const TenantAfterDisableEventHandler = createAbstraction("TenantManager/TenantAfterDisableEventHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","TenantBeforeDisableEvent","eventType","getHandlerAbstraction","TenantBeforeDisableEventHandler","TenantAfterDisableEvent","TenantAfterDisableEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport type { Tenant } from \"~/shared/Tenant.js\";\n\nexport interface TenantBeforeDisablePayload {\n    tenant: Tenant;\n}\n\nexport interface TenantAfterDisablePayload {\n    tenant: Tenant;\n}\n\nexport class TenantBeforeDisableEvent extends DomainEvent<TenantBeforeDisablePayload> {\n    eventType = \"tenant.beforeDisable\" as const;\n\n    getHandlerAbstraction() {\n        return TenantBeforeDisableEventHandler;\n    }\n}\n\nexport const TenantBeforeDisableEventHandler = createAbstraction<\n    IEventHandler<TenantBeforeDisableEvent>\n>(\"TenantManager/TenantBeforeDisableEventHandler\");\n\nexport namespace TenantBeforeDisableEventHandler {\n    export type Interface = IEventHandler<TenantBeforeDisableEvent>;\n    export type Event = TenantBeforeDisableEvent;\n}\n\nexport class TenantAfterDisableEvent extends DomainEvent<TenantAfterDisablePayload> {\n    eventType = \"tenant.afterDisable\" as const;\n\n    getHandlerAbstraction() {\n        return TenantAfterDisableEventHandler;\n    }\n}\n\nexport const TenantAfterDisableEventHandler = createAbstraction<\n    IEventHandler<TenantAfterDisableEvent>\n>(\"TenantManager/TenantAfterDisableEventHandler\");\n\nexport namespace TenantAfterDisableEventHandler {\n    export type Interface = IEventHandler<TenantAfterDisableEvent>;\n    export type Event = TenantAfterDisableEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,0CAA0C;AAYtE,OAAO,MAAMC,wBAAwB,SAASD,WAAW,CAA6B;EAClFE,SAAS,GAAG,sBAAsB;EAElCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,+BAA+B;EAC1C;AACJ;AAEA,OAAO,MAAMA,+BAA+B,GAAGL,iBAAiB,CAE9D,+CAA+C,CAAC;AAOlD,OAAO,MAAMM,uBAAuB,SAASL,WAAW,CAA4B;EAChFE,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,8BAA8B;EACzC;AACJ;AAEA,OAAO,MAAMA,8BAA8B,GAAGP,iBAAiB,CAE7D,8CAA8C,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const DisableTenantFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/api/features/DisableTenant/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import DisableTenantUseCase from "./DisableTenantUseCase.js";
+export const DisableTenantFeature = createFeature({
+  name: "DisableTenant",
+  register(container) {
+    // Register use case (transient scope)
+    container.register(DisableTenantUseCase);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","DisableTenantUseCase","DisableTenantFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport DisableTenantUseCase from \"./DisableTenantUseCase.js\";\n\nexport const DisableTenantFeature = createFeature({\n    name: \"DisableTenant\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(DisableTenantUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,OAAOC,oBAAoB;AAE3B,OAAO,MAAMC,oBAAoB,GAAGF,aAAa,CAAC;EAC9CG,IAAI,EAAE,eAAe;EACrBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,oBAAoB,CAAC;EAC5C;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,20 @@
+import { EnableTenantUseCase as UseCaseAbstraction } 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";
+import { UpdateTenantUseCase as ApiCoreUpdateTenant } from "@webiny/api-core/features/tenancy/UpdateTenant";
+import { UpdateTenantUseCase as TenantManagerUpdateTenant } from "../UpdateTenant/abstractions.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+declare class EnableTenantUseCase implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private eventPublisher;
+    private coreUpdateTenant;
+    private tmUpdateTenant;
+    private tmGetTenantById;
+    constructor(identityContext: IdentityContext.Interface, eventPublisher: EventPublisher.Interface, coreUpdateTenant: ApiCoreUpdateTenant.Interface, tmUpdateTenant: TenantManagerUpdateTenant.Interface, tmGetTenantById: GetTenantByIdUseCase.Interface);
+    execute(tenantId: string): Promise<Result<void, UseCaseAbstraction.Error>>;
+}
+declare const _default: typeof EnableTenantUseCase & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IEnableTenantUseCase>;
+};
+export default _default;

package/api/features/EnableTenant/EnableTenantUseCase.js

@@ -0,0 +1,68 @@
+import { EnableTenantUseCase as UseCaseAbstraction } 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";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { UpdateTenantUseCase as ApiCoreUpdateTenant } from "@webiny/api-core/features/tenancy/UpdateTenant";
+import { UpdateTenantUseCase as TenantManagerUpdateTenant } from "../UpdateTenant/abstractions.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+import { TenantBeforeEnableEvent, TenantAfterEnableEvent } from "./events.js";
+import { TenantPersistenceError } from "../../domain/errors.js";
+class 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) {
+    // Authorization checks
+    const identity = this.identityContext.getIdentity();
+    if (!identity.isAdmin() || !this.identityContext.getPermission("tm.tenant")) {
+      return Result.fail(new NotAuthorizedError({
+        message: "Not authorized to enable tenants."
+      }));
+    }
+
+    // Get current tenant to verify it exists
+    const getTenantResult = await this.tmGetTenantById.execute(tenantId);
+    if (getTenantResult.isFail()) {
+      return Result.fail(getTenantResult.error);
+    }
+    const tenant = getTenantResult.value;
+
+    // Publish before event
+    await this.eventPublisher.publish(new TenantBeforeEnableEvent({
+      tenant
+    }));
+
+    // Update api-core tenant first
+    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}`)));
+    }
+
+    // Update tenant-manager CMS entry
+    const updatedTenantResult = await this.tmUpdateTenant.execute(tenantId, {
+      status: "enabled"
+    });
+    if (updatedTenantResult.isFail()) {
+      return Result.fail(updatedTenantResult.error);
+    }
+
+    // Publish after event
+    await this.eventPublisher.publish(new TenantAfterEnableEvent({
+      tenant: updatedTenantResult.value
+    }));
+    return Result.ok();
+  }
+}
+export default UseCaseAbstraction.createImplementation({
+  implementation: EnableTenantUseCase,
+  dependencies: [IdentityContext, EventPublisher, ApiCoreUpdateTenant, TenantManagerUpdateTenant, GetTenantByIdUseCase]
+});
+
+//# sourceMappingURL=EnableTenantUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["EnableTenantUseCase","UseCaseAbstraction","Result","IdentityContext","EventPublisher","NotAuthorizedError","UpdateTenantUseCase","ApiCoreUpdateTenant","TenantManagerUpdateTenant","GetTenantByIdUseCase","TenantBeforeEnableEvent","TenantAfterEnableEvent","TenantPersistenceError","constructor","identityContext","eventPublisher","coreUpdateTenant","tmUpdateTenant","tmGetTenantById","execute","tenantId","identity","getIdentity","isAdmin","getPermission","fail","message","getTenantResult","isFail","error","tenant","value","publish","apiCoreResult","status","Error","updatedTenantResult","ok","createImplementation","implementation","dependencies"],"sources":["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\";\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        const identity = this.identityContext.getIdentity();\n        if (!identity.isAdmin() || !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"],"mappings":"AAAA,SAASA,mBAAmB,IAAIC,kBAAkB;AAClD,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,0CAA0C;AAC1E,SAASC,cAAc,QAAQ,0CAA0C;AACzE,SAASC,kBAAkB,QAAQ,qDAAqD;AACxF,SAASC,mBAAmB,IAAIC,mBAAmB,QAAQ,gDAAgD;AAC3G,SAASD,mBAAmB,IAAIE,yBAAyB;AACzD,SAASC,oBAAoB;AAC7B,SAASC,uBAAuB,EAAEC,sBAAsB;AACxD,SAASC,sBAAsB;AAE/B,MAAMZ,mBAAmB,CAAyC;EAC9Da,WAAWA,CACCC,eAA0C,EAC1CC,cAAwC,EACxCC,gBAA+C,EAC/CC,cAAmD,EACnDC,eAA+C,EACzD;IAAA,KALUJ,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,gBAA+C,GAA/CA,gBAA+C;IAAA,KAC/CC,cAAmD,GAAnDA,cAAmD;IAAA,KACnDC,eAA+C,GAA/CA,eAA+C;EACxD;EAEH,MAAMC,OAAOA,CAACC,QAAgB,EAAmD;IAC7E;IACA,MAAMC,QAAQ,GAAG,IAAI,CAACP,eAAe,CAACQ,WAAW,CAAC,CAAC;IACnD,IAAI,CAACD,QAAQ,CAACE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAACT,eAAe,CAACU,aAAa,CAAC,WAAW,CAAC,EAAE;MACzE,OAAOtB,MAAM,CAACuB,IAAI,CACd,IAAIpB,kBAAkB,CAAC;QAAEqB,OAAO,EAAE;MAAoC,CAAC,CAC3E,CAAC;IACL;;IAEA;IACA,MAAMC,eAAe,GAAG,MAAM,IAAI,CAACT,eAAe,CAACC,OAAO,CAACC,QAAQ,CAAC;IACpE,IAAIO,eAAe,CAACC,MAAM,CAAC,CAAC,EAAE;MAC1B,OAAO1B,MAAM,CAACuB,IAAI,CAACE,eAAe,CAACE,KAAK,CAAC;IAC7C;IAEA,MAAMC,MAAM,GAAGH,eAAe,CAACI,KAAK;;IAEpC;IACA,MAAM,IAAI,CAAChB,cAAc,CAACiB,OAAO,CAAC,IAAItB,uBAAuB,CAAC;MAAEoB;IAAO,CAAC,CAAC,CAAC;;IAE1E;IACA,MAAMG,aAAa,GAAG,MAAM,IAAI,CAACjB,gBAAgB,CAACG,OAAO,CAACC,QAAQ,EAAE;MAChEc,MAAM,EAAE;IACZ,CAAC,CAAC;IAEF,IAAID,aAAa,CAACL,MAAM,CAAC,CAAC,EAAE;MACxB,OAAO1B,MAAM,CAACuB,IAAI,CACd,IAAIb,sBAAsB,CACtB,IAAIuB,KAAK,CAAC,qCAAqCF,aAAa,CAACJ,KAAK,EAAE,CACxE,CACJ,CAAC;IACL;;IAEA;IACA,MAAMO,mBAAmB,GAAG,MAAM,IAAI,CAACnB,cAAc,CAACE,OAAO,CAACC,QAAQ,EAAE;MACpEc,MAAM,EAAE;IACZ,CAAC,CAAC;IAEF,IAAIE,mBAAmB,CAACR,MAAM,CAAC,CAAC,EAAE;MAC9B,OAAO1B,MAAM,CAACuB,IAAI,CAACW,mBAAmB,CAACP,KAAK,CAAC;IACjD;;IAEA;IACA,MAAM,IAAI,CAACd,cAAc,CAACiB,OAAO,CAC7B,IAAIrB,sBAAsB,CAAC;MAAEmB,MAAM,EAAEM,mBAAmB,CAACL;IAAM,CAAC,CACpE,CAAC;IAED,OAAO7B,MAAM,CAACmC,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,eAAepC,kBAAkB,CAACqC,oBAAoB,CAAC;EACnDC,cAAc,EAAEvC,mBAAmB;EACnCwC,YAAY,EAAE,CACVrC,eAAe,EACfC,cAAc,EACdG,mBAAmB,EACnBC,yBAAyB,EACzBC,oBAAoB;AAE5B,CAAC,CAAC","ignoreList":[]}