@webiny/api-core 0.0.0-unstable.3c5210ad37

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

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","CreateTenantRepository","RepositoryAbstraction","CreateTenantGateway","TenantCache","CreateTenantRepositoryImpl","constructor","gateway","cache","create","tenant","created","createTenant","prime","id","abstraction","implementation","dependencies"],"sources":["CreateTenantRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { CreateTenantRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { CreateTenantGateway } from \"./abstractions.js\";\nimport { TenantCache } from \"../shared/abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nclass CreateTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: CreateTenantGateway.Interface,\n        private cache: TenantCache.Interface\n    ) {}\n\n    async create(tenant: Tenant) {\n        const created = await this.gateway.createTenant(tenant);\n        this.cache.prime(created.id, created);\n        return created;\n    }\n}\n\nexport const CreateTenantRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: CreateTenantRepositoryImpl,\n    dependencies: [CreateTenantGateway, TenantCache]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,YAAY;AACjD,SAASC,sBAAsB,IAAIC,qBAAqB;AACxD,SAASC,mBAAmB;AAC5B,SAASC,WAAW;AAGpB,MAAMC,0BAA0B,CAA4C;EACxEC,WAAWA,CACCC,OAAsC,EACtCC,KAA4B,EACtC;IAAA,KAFUD,OAAsC,GAAtCA,OAAsC;IAAA,KACtCC,KAA4B,GAA5BA,KAA4B;EACrC;EAEH,MAAMC,MAAMA,CAACC,MAAc,EAAE;IACzB,MAAMC,OAAO,GAAG,MAAM,IAAI,CAACJ,OAAO,CAACK,YAAY,CAACF,MAAM,CAAC;IACvD,IAAI,CAACF,KAAK,CAACK,KAAK,CAACF,OAAO,CAACG,EAAE,EAAEH,OAAO,CAAC;IACrC,OAAOA,OAAO;EAClB;AACJ;AAEA,OAAO,MAAMV,sBAAsB,GAAGD,oBAAoB,CAAC;EACvDe,WAAW,EAAEb,qBAAqB;EAClCc,cAAc,EAAEX,0BAA0B;EAC1CY,YAAY,EAAE,CAACd,mBAAmB,EAAEC,WAAW;AACnD,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "../../../features/eventPublisher/index.js";
+import { CreateTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { CreateTenantRepository } from "./abstractions.js";
+import type { Tenant, CreateTenantInput } from "../../../types/tenancy.js";
+import { CreateTenantError } from "../../../features/tenancy/CreateTenant/errors.js";
+declare class CreateTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private eventPublisher;
+    private repository;
+    constructor(eventPublisher: EventPublisher.Interface, repository: CreateTenantRepository.Interface);
+    execute(data: CreateTenantInput): Promise<Result<Tenant, never> | Result<never, CreateTenantError>>;
+}
+export declare const CreateTenantUseCase: import("@webiny/di").Implementation<typeof CreateTenantUseCaseImpl>;
+export {};

package/features/tenancy/CreateTenant/CreateTenantUseCase.js

@@ -0,0 +1,51 @@
+import { Result, createImplementation } from "@webiny/feature/api";
+import { EventPublisher } from "../../eventPublisher/index.js";
+import { mdbid } from "@webiny/utils";
+import { CreateTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { CreateTenantRepository } from "./abstractions.js";
+import { TenantBeforeCreateEvent, TenantAfterCreateEvent } from "./events.js";
+import { CreateTenantError } from "./errors.js";
+class CreateTenantUseCaseImpl {
+  constructor(eventPublisher, repository) {
+    this.eventPublisher = eventPublisher;
+    this.repository = repository;
+  }
+  async execute(data) {
+    const tenant = {
+      ...data,
+      id: data.id ?? mdbid(),
+      status: "disabled",
+      isInstalled: false,
+      settings: {
+        ...(data.settings || {})
+      },
+      savedOn: new Date().toISOString(),
+      createdOn: new Date().toISOString(),
+      parent: data.parent || null
+    };
+    await this.eventPublisher.publish(new TenantBeforeCreateEvent({
+      tenant,
+      input: data
+    }));
+    let createdTenant;
+    try {
+      createdTenant = await this.repository.create(tenant);
+    } catch (e) {
+      return Result.fail(new CreateTenantError({
+        reason: e.message
+      }));
+    }
+    await this.eventPublisher.publish(new TenantAfterCreateEvent({
+      tenant: createdTenant,
+      input: data
+    }));
+    return Result.ok(createdTenant);
+  }
+}
+export const CreateTenantUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: CreateTenantUseCaseImpl,
+  dependencies: [EventPublisher, CreateTenantRepository]
+});
+
+//# sourceMappingURL=CreateTenantUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","createImplementation","EventPublisher","mdbid","CreateTenantUseCase","UseCaseAbstraction","CreateTenantRepository","TenantBeforeCreateEvent","TenantAfterCreateEvent","CreateTenantError","CreateTenantUseCaseImpl","constructor","eventPublisher","repository","execute","data","tenant","id","status","isInstalled","settings","savedOn","Date","toISOString","createdOn","parent","publish","input","createdTenant","create","e","fail","reason","message","ok","abstraction","implementation","dependencies"],"sources":["CreateTenantUseCase.ts"],"sourcesContent":["import { Result, createImplementation } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"~/features/eventPublisher/index.js\";\nimport { mdbid } from \"@webiny/utils\";\nimport { CreateTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { CreateTenantRepository } from \"./abstractions.js\";\nimport { TenantBeforeCreateEvent, TenantAfterCreateEvent } from \"./events.js\";\nimport type { Tenant, CreateTenantInput } from \"~/types/tenancy.js\";\nimport { CreateTenantError } from \"~/features/tenancy/CreateTenant/errors.js\";\n\nclass CreateTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private eventPublisher: EventPublisher.Interface,\n        private repository: CreateTenantRepository.Interface\n    ) {}\n\n    async execute(data: CreateTenantInput) {\n        const tenant: Tenant = {\n            ...data,\n            id: data.id ?? mdbid(),\n            status: \"disabled\",\n            isInstalled: false,\n            settings: {\n                ...(data.settings || {})\n            },\n            savedOn: new Date().toISOString(),\n            createdOn: new Date().toISOString(),\n            parent: data.parent || null\n        };\n\n        await this.eventPublisher.publish(new TenantBeforeCreateEvent({ tenant, input: data }));\n\n        let createdTenant: Tenant;\n        try {\n            createdTenant = await this.repository.create(tenant);\n        } catch (e) {\n            return Result.fail(new CreateTenantError({ reason: e.message }));\n        }\n\n        await this.eventPublisher.publish(\n            new TenantAfterCreateEvent({ tenant: createdTenant, input: data })\n        );\n\n        return Result.ok(createdTenant);\n    }\n}\n\nexport const CreateTenantUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: CreateTenantUseCaseImpl,\n    dependencies: [EventPublisher, CreateTenantRepository]\n});\n"],"mappings":"AAAA,SAASA,MAAM,EAAEC,oBAAoB,QAAQ,qBAAqB;AAClE,SAASC,cAAc;AACvB,SAASC,KAAK,QAAQ,eAAe;AACrC,SAASC,mBAAmB,IAAIC,kBAAkB;AAClD,SAASC,sBAAsB;AAC/B,SAASC,uBAAuB,EAAEC,sBAAsB;AAExD,SAASC,iBAAiB;AAE1B,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CACCC,cAAwC,EACxCC,UAA4C,EACtD;IAAA,KAFUD,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,UAA4C,GAA5CA,UAA4C;EACrD;EAEH,MAAMC,OAAOA,CAACC,IAAuB,EAAE;IACnC,MAAMC,MAAc,GAAG;MACnB,GAAGD,IAAI;MACPE,EAAE,EAAEF,IAAI,CAACE,EAAE,IAAId,KAAK,CAAC,CAAC;MACtBe,MAAM,EAAE,UAAU;MAClBC,WAAW,EAAE,KAAK;MAClBC,QAAQ,EAAE;QACN,IAAIL,IAAI,CAACK,QAAQ,IAAI,CAAC,CAAC;MAC3B,CAAC;MACDC,OAAO,EAAE,IAAIC,IAAI,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC;MACjCC,SAAS,EAAE,IAAIF,IAAI,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC;MACnCE,MAAM,EAAEV,IAAI,CAACU,MAAM,IAAI;IAC3B,CAAC;IAED,MAAM,IAAI,CAACb,cAAc,CAACc,OAAO,CAAC,IAAInB,uBAAuB,CAAC;MAAES,MAAM;MAAEW,KAAK,EAAEZ;IAAK,CAAC,CAAC,CAAC;IAEvF,IAAIa,aAAqB;IACzB,IAAI;MACAA,aAAa,GAAG,MAAM,IAAI,CAACf,UAAU,CAACgB,MAAM,CAACb,MAAM,CAAC;IACxD,CAAC,CAAC,OAAOc,CAAC,EAAE;MACR,OAAO9B,MAAM,CAAC+B,IAAI,CAAC,IAAItB,iBAAiB,CAAC;QAAEuB,MAAM,EAAEF,CAAC,CAACG;MAAQ,CAAC,CAAC,CAAC;IACpE;IAEA,MAAM,IAAI,CAACrB,cAAc,CAACc,OAAO,CAC7B,IAAIlB,sBAAsB,CAAC;MAAEQ,MAAM,EAAEY,aAAa;MAAED,KAAK,EAAEZ;IAAK,CAAC,CACrE,CAAC;IAED,OAAOf,MAAM,CAACkC,EAAE,CAACN,aAAa,CAAC;EACnC;AACJ;AAEA,OAAO,MAAMxB,mBAAmB,GAAGH,oBAAoB,CAAC;EACpDkC,WAAW,EAAE9B,kBAAkB;EAC/B+B,cAAc,EAAE1B,uBAAuB;EACvC2B,YAAY,EAAE,CAACnC,cAAc,EAAEI,sBAAsB;AACzD,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,55 @@
+import { Result } from "@webiny/feature/api";
+import type { IEventHandler, DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant, CreateTenantInput } from "../../../types/tenancy.js";
+import type { TenantBeforeCreatePayload, TenantAfterCreatePayload } from "./events.js";
+import { CreateTenantError } from "./errors.js";
+/**
+ * Errors
+ */
+export interface ICreateTenantErrors {
+    base: CreateTenantError;
+}
+/**
+ * Use Case
+ */
+export interface ICreateTenantUseCase {
+    execute(data: CreateTenantInput): Promise<Result<Tenant, ICreateTenantErrors[keyof ICreateTenantErrors]>>;
+}
+export declare const CreateTenantUseCase: import("@webiny/di").Abstraction<ICreateTenantUseCase>;
+export declare namespace CreateTenantUseCase {
+    type Interface = ICreateTenantUseCase;
+    type Errors = ICreateTenantErrors[keyof ICreateTenantErrors];
+}
+/**
+ * Repository
+ */
+export interface ICreateTenantRepository {
+    create(tenant: Tenant): Promise<Tenant>;
+}
+export declare const CreateTenantRepository: import("@webiny/di").Abstraction<ICreateTenantRepository>;
+export declare namespace CreateTenantRepository {
+    type Interface = ICreateTenantRepository;
+}
+/**
+ * Gateway
+ */
+export interface ICreateTenantGateway {
+    createTenant(data: Tenant): Promise<Tenant>;
+}
+export declare const CreateTenantGateway: import("@webiny/di").Abstraction<ICreateTenantGateway>;
+export declare namespace CreateTenantGateway {
+    type Interface = ICreateTenantGateway;
+}
+/**
+ * Event Handlers
+ */
+export declare const TenantBeforeCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantBeforeCreatePayload>>>;
+export declare namespace TenantBeforeCreateHandler {
+    type Interface = IEventHandler<DomainEvent<TenantBeforeCreatePayload>>;
+    type Event = DomainEvent<TenantBeforeCreatePayload>;
+}
+export declare const TenantAfterCreateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantAfterCreatePayload>>>;
+export declare namespace TenantAfterCreateHandler {
+    type Interface = IEventHandler<DomainEvent<TenantAfterCreatePayload>>;
+    type Event = DomainEvent<TenantAfterCreatePayload>;
+}

package/features/tenancy/CreateTenant/abstractions.js

@@ -0,0 +1,30 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * Errors
+ */
+
+/**
+ * Use Case
+ */
+
+export const CreateTenantUseCase = createAbstraction("CreateTenantUseCase");
+
+/**
+ * Repository
+ */
+
+export const CreateTenantRepository = createAbstraction("CreateTenantRepository");
+
+/**
+ * Gateway
+ */
+
+export const CreateTenantGateway = createAbstraction("CreateTenantGateway");
+/**
+ * Event Handlers
+ */
+export const TenantBeforeCreateHandler = createAbstraction("TenantBeforeCreateHandler");
+export const TenantAfterCreateHandler = createAbstraction("TenantAfterCreateHandler");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CreateTenantUseCase","CreateTenantRepository","CreateTenantGateway","TenantBeforeCreateHandler","TenantAfterCreateHandler"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { IEventHandler, DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant, CreateTenantInput } from \"~/types/tenancy.js\";\nimport type { TenantBeforeCreatePayload, TenantAfterCreatePayload } from \"./events.js\";\nimport { CreateTenantError } from \"./errors.js\";\n\n/**\n * Errors\n */\nexport interface ICreateTenantErrors {\n    base: CreateTenantError;\n}\n\n/**\n * Use Case\n */\nexport interface ICreateTenantUseCase {\n    execute(\n        data: CreateTenantInput\n    ): Promise<Result<Tenant, ICreateTenantErrors[keyof ICreateTenantErrors]>>;\n}\n\nexport const CreateTenantUseCase = createAbstraction<ICreateTenantUseCase>(\"CreateTenantUseCase\");\n\nexport namespace CreateTenantUseCase {\n    export type Interface = ICreateTenantUseCase;\n    export type Errors = ICreateTenantErrors[keyof ICreateTenantErrors];\n}\n\n/**\n * Repository\n */\nexport interface ICreateTenantRepository {\n    create(tenant: Tenant): Promise<Tenant>;\n}\n\nexport const CreateTenantRepository =\n    createAbstraction<ICreateTenantRepository>(\"CreateTenantRepository\");\n\nexport namespace CreateTenantRepository {\n    export type Interface = ICreateTenantRepository;\n}\n\n/**\n * Gateway\n */\nexport interface ICreateTenantGateway {\n    createTenant(data: Tenant): Promise<Tenant>;\n}\n\nexport const CreateTenantGateway = createAbstraction<ICreateTenantGateway>(\"CreateTenantGateway\");\n\nexport namespace CreateTenantGateway {\n    export type Interface = ICreateTenantGateway;\n}\n\n/**\n * Event Handlers\n */\nexport const TenantBeforeCreateHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantBeforeCreatePayload>>\n>(\"TenantBeforeCreateHandler\");\n\nexport namespace TenantBeforeCreateHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantBeforeCreatePayload>>;\n    export type Event = DomainEvent<TenantBeforeCreatePayload>;\n}\n\nexport const TenantAfterCreateHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantAfterCreatePayload>>\n>(\"TenantAfterCreateHandler\");\n\nexport namespace TenantAfterCreateHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantAfterCreatePayload>>;\n    export type Event = DomainEvent<TenantAfterCreatePayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAM/D;AACA;AACA;;AAKA;AACA;AACA;;AAOA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC;;AAOjG;AACA;AACA;;AAKA,OAAO,MAAME,sBAAsB,GAC/BF,iBAAiB,CAA0B,wBAAwB,CAAC;;AAMxE;AACA;AACA;;AAKA,OAAO,MAAMG,mBAAmB,GAAGH,iBAAiB,CAAuB,qBAAqB,CAAC;AAMjG;AACA;AACA;AACA,OAAO,MAAMI,yBAAyB,GAAGJ,iBAAiB,CAExD,2BAA2B,CAAC;AAO9B,OAAO,MAAMK,wBAAwB,GAAGL,iBAAiB,CAEvD,0BAA0B,CAAC","ignoreList":[]}

package/features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.d.ts

@@ -0,0 +1,11 @@
+import { CreateTenantUseCase } from "../abstractions.js";
+import type { CreateTenantInput } from "../../../../types/tenancy.js";
+import { WcpContext } from "../../../../features/wcp/WcpContext/index.js";
+declare class CreateTenantWithWcpIncrementImpl implements CreateTenantUseCase.Interface {
+    private wcp;
+    private decoratee;
+    constructor(wcp: WcpContext.Interface, decoratee: CreateTenantUseCase.Interface);
+    execute(data: CreateTenantInput): Promise<import("@webiny/feature/api").Result<import("~/types/tenancy.js").Tenant, import("../errors.js").CreateTenantError>>;
+}
+export declare const CreateTenantWithWcpIncrement: typeof CreateTenantWithWcpIncrementImpl;
+export {};

package/features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.js

@@ -0,0 +1,24 @@
+import { createDecorator } from "@webiny/feature/api";
+import { CreateTenantUseCase } from "../abstractions.js";
+import { WcpContext } from "../../../wcp/WcpContext/index.js";
+class CreateTenantWithWcpIncrementImpl {
+  constructor(wcp, decoratee) {
+    this.wcp = wcp;
+    this.decoratee = decoratee;
+  }
+  async execute(data) {
+    await this.wcp.incrementTenants();
+    const result = await this.decoratee.execute(data);
+    if (result.isFail()) {
+      await this.wcp.decrementTenants();
+    }
+    return result;
+  }
+}
+export const CreateTenantWithWcpIncrement = createDecorator({
+  abstraction: CreateTenantUseCase,
+  decorator: CreateTenantWithWcpIncrementImpl,
+  dependencies: [WcpContext]
+});
+
+//# sourceMappingURL=CreateTenantWithWcpIncrement.js.map

package/features/tenancy/CreateTenant/decorators/CreateTenantWithWcpIncrement.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createDecorator","CreateTenantUseCase","WcpContext","CreateTenantWithWcpIncrementImpl","constructor","wcp","decoratee","execute","data","incrementTenants","result","isFail","decrementTenants","CreateTenantWithWcpIncrement","abstraction","decorator","dependencies"],"sources":["CreateTenantWithWcpIncrement.ts"],"sourcesContent":["import { createDecorator } from \"@webiny/feature/api\";\nimport { CreateTenantUseCase } from \"../abstractions.js\";\nimport type { CreateTenantInput } from \"~/types/tenancy.js\";\nimport { WcpContext } from \"~/features/wcp/WcpContext/index.js\";\n\nclass CreateTenantWithWcpIncrementImpl implements CreateTenantUseCase.Interface {\n    constructor(\n        private wcp: WcpContext.Interface,\n        private decoratee: CreateTenantUseCase.Interface\n    ) {}\n\n    async execute(data: CreateTenantInput) {\n        await this.wcp.incrementTenants();\n\n        const result = await this.decoratee.execute(data);\n\n        if (result.isFail()) {\n            await this.wcp.decrementTenants();\n        }\n\n        return result;\n    }\n}\n\nexport const CreateTenantWithWcpIncrement = createDecorator({\n    abstraction: CreateTenantUseCase,\n    decorator: CreateTenantWithWcpIncrementImpl,\n    dependencies: [WcpContext]\n});\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,qBAAqB;AACrD,SAASC,mBAAmB;AAE5B,SAASC,UAAU;AAEnB,MAAMC,gCAAgC,CAA0C;EAC5EC,WAAWA,CACCC,GAAyB,EACzBC,SAAwC,EAClD;IAAA,KAFUD,GAAyB,GAAzBA,GAAyB;IAAA,KACzBC,SAAwC,GAAxCA,SAAwC;EACjD;EAEH,MAAMC,OAAOA,CAACC,IAAuB,EAAE;IACnC,MAAM,IAAI,CAACH,GAAG,CAACI,gBAAgB,CAAC,CAAC;IAEjC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,SAAS,CAACC,OAAO,CAACC,IAAI,CAAC;IAEjD,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,MAAM,IAAI,CAACN,GAAG,CAACO,gBAAgB,CAAC,CAAC;IACrC;IAEA,OAAOF,MAAM;EACjB;AACJ;AAEA,OAAO,MAAMG,4BAA4B,GAAGb,eAAe,CAAC;EACxDc,WAAW,EAAEb,mBAAmB;EAChCc,SAAS,EAAEZ,gCAAgC;EAC3Ca,YAAY,EAAE,CAACd,UAAU;AAC7B,CAAC,CAAC","ignoreList":[]}

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

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

package/features/tenancy/CreateTenant/errors.js

@@ -0,0 +1,12 @@
+import { BaseError } from "@webiny/feature/api";
+export class CreateTenantError extends BaseError {
+  code = "CREATE_TENANT";
+  constructor(data) {
+    super({
+      message: `Failed to create tenant`,
+      data
+    });
+  }
+}
+
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["BaseError","CreateTenantError","code","constructor","data","message"],"sources":["errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class CreateTenantError extends BaseError {\n    override readonly code = \"CREATE_TENANT\" as const;\n\n    constructor(data: any) {\n        super({\n            message: `Failed to create tenant`,\n            data\n        });\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,qBAAqB;AAE/C,OAAO,MAAMC,iBAAiB,SAASD,SAAS,CAAC;EAC3BE,IAAI,GAAG,eAAe;EAExCC,WAAWA,CAACC,IAAS,EAAE;IACnB,KAAK,CAAC;MACFC,OAAO,EAAE,yBAAyB;MAClCD;IACJ,CAAC,CAAC;EACN;AACJ","ignoreList":[]}

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

@@ -0,0 +1,18 @@
+import { type CreateTenantInput, Tenant } from "../../../types/tenancy.js";
+import { DomainEvent } from "../../../features/eventPublisher/index.js";
+export interface TenantBeforeCreatePayload {
+    tenant: Tenant;
+    input: CreateTenantInput & Record<string, any>;
+}
+export interface TenantAfterCreatePayload {
+    tenant: Tenant;
+    input: CreateTenantInput & Record<string, any>;
+}
+export declare class TenantBeforeCreateEvent extends DomainEvent<TenantBeforeCreatePayload> {
+    eventType: "tenant.beforeCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantBeforeCreatePayload>>>;
+}
+export declare class TenantAfterCreateEvent extends DomainEvent<TenantAfterCreatePayload> {
+    eventType: "tenant.afterCreate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantAfterCreatePayload>>>;
+}

package/features/tenancy/CreateTenant/events.js

@@ -0,0 +1,16 @@
+import { TenantBeforeCreateHandler, TenantAfterCreateHandler } from "./abstractions.js";
+import { DomainEvent } from "../../eventPublisher/index.js";
+export class TenantBeforeCreateEvent extends DomainEvent {
+  eventType = "tenant.beforeCreate";
+  getHandlerAbstraction() {
+    return TenantBeforeCreateHandler;
+  }
+}
+export class TenantAfterCreateEvent extends DomainEvent {
+  eventType = "tenant.afterCreate";
+  getHandlerAbstraction() {
+    return TenantAfterCreateHandler;
+  }
+}
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TenantBeforeCreateHandler","TenantAfterCreateHandler","DomainEvent","TenantBeforeCreateEvent","eventType","getHandlerAbstraction","TenantAfterCreateEvent"],"sources":["events.ts"],"sourcesContent":["import { type CreateTenantInput, Tenant } from \"~/types/tenancy.js\";\nimport { TenantBeforeCreateHandler, TenantAfterCreateHandler } from \"./abstractions.js\";\nimport { DomainEvent } from \"~/features/eventPublisher/index.js\";\n\nexport interface TenantBeforeCreatePayload {\n    tenant: Tenant;\n    input: CreateTenantInput & Record<string, any>;\n}\n\nexport interface TenantAfterCreatePayload {\n    tenant: Tenant;\n    input: CreateTenantInput & Record<string, any>;\n}\n\nexport class TenantBeforeCreateEvent extends DomainEvent<TenantBeforeCreatePayload> {\n    eventType = \"tenant.beforeCreate\" as const;\n\n    getHandlerAbstraction() {\n        return TenantBeforeCreateHandler;\n    }\n}\n\nexport class TenantAfterCreateEvent extends DomainEvent<TenantAfterCreatePayload> {\n    eventType = \"tenant.afterCreate\" as const;\n\n    getHandlerAbstraction() {\n        return TenantAfterCreateHandler;\n    }\n}\n"],"mappings":"AACA,SAASA,yBAAyB,EAAEC,wBAAwB;AAC5D,SAASC,WAAW;AAYpB,OAAO,MAAMC,uBAAuB,SAASD,WAAW,CAA4B;EAChFE,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOL,yBAAyB;EACpC;AACJ;AAEA,OAAO,MAAMM,sBAAsB,SAASJ,WAAW,CAA2B;EAC9EE,SAAS,GAAG,oBAAoB;EAEhCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOJ,wBAAwB;EACnC;AACJ","ignoreList":[]}

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

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

package/features/tenancy/CreateTenant/feature.js

@@ -0,0 +1,16 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateTenantUseCase } from "./CreateTenantUseCase.js";
+import { CreateTenantRepository } from "./CreateTenantRepository.js";
+import { CreateTenantGateway } from "./CreateTenantGateway.js";
+import { CreateTenantWithWcpIncrement } from "./decorators/CreateTenantWithWcpIncrement.js";
+export const CreateTenantFeature = createFeature({
+  name: "CreateTenant",
+  register(container) {
+    container.register(CreateTenantUseCase);
+    container.register(CreateTenantGateway).inSingletonScope();
+    container.register(CreateTenantRepository).inSingletonScope();
+    container.registerDecorator(CreateTenantWithWcpIncrement);
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CreateTenantUseCase","CreateTenantRepository","CreateTenantGateway","CreateTenantWithWcpIncrement","CreateTenantFeature","name","register","container","inSingletonScope","registerDecorator"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { CreateTenantUseCase } from \"./CreateTenantUseCase.js\";\nimport { CreateTenantRepository } from \"./CreateTenantRepository.js\";\nimport { CreateTenantGateway } from \"./CreateTenantGateway.js\";\nimport { CreateTenantWithWcpIncrement } from \"./decorators/CreateTenantWithWcpIncrement.js\";\n\nexport const CreateTenantFeature = createFeature({\n    name: \"CreateTenant\",\n    register(container: Container) {\n        container.register(CreateTenantUseCase);\n        container.register(CreateTenantGateway).inSingletonScope();\n        container.register(CreateTenantRepository).inSingletonScope();\n        container.registerDecorator(CreateTenantWithWcpIncrement);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB;AAC/B,SAASC,mBAAmB;AAC5B,SAASC,4BAA4B;AAErC,OAAO,MAAMC,mBAAmB,GAAGL,aAAa,CAAC;EAC7CM,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACN,mBAAmB,CAAC;IACvCO,SAAS,CAACD,QAAQ,CAACJ,mBAAmB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC1DD,SAAS,CAACD,QAAQ,CAACL,sBAAsB,CAAC,CAACO,gBAAgB,CAAC,CAAC;IAC7DD,SAAS,CAACE,iBAAiB,CAACN,4BAA4B,CAAC;EAC7D;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,3 @@
+export { CreateTenantFeature } from "./feature.js";
+export { CreateTenantUseCase, CreateTenantRepository, CreateTenantGateway, TenantBeforeCreateHandler, TenantAfterCreateHandler } from "./abstractions.js";
+export { TenantBeforeCreateEvent, TenantAfterCreateEvent } from "./events.js";

package/features/tenancy/CreateTenant/index.js

@@ -0,0 +1,5 @@
+export { CreateTenantFeature } from "./feature.js";
+export { CreateTenantUseCase, CreateTenantRepository, CreateTenantGateway, TenantBeforeCreateHandler, TenantAfterCreateHandler } from "./abstractions.js";
+export { TenantBeforeCreateEvent, TenantAfterCreateEvent } from "./events.js";
+
+//# sourceMappingURL=index.js.map

package/features/tenancy/CreateTenant/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CreateTenantFeature","CreateTenantUseCase","CreateTenantRepository","CreateTenantGateway","TenantBeforeCreateHandler","TenantAfterCreateHandler","TenantBeforeCreateEvent","TenantAfterCreateEvent"],"sources":["index.ts"],"sourcesContent":["export { CreateTenantFeature } from \"./feature.js\";\nexport {\n    CreateTenantUseCase,\n    CreateTenantRepository,\n    CreateTenantGateway,\n    TenantBeforeCreateHandler,\n    TenantAfterCreateHandler\n} from \"./abstractions.js\";\nexport { TenantBeforeCreateEvent, TenantAfterCreateEvent } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,mBAAmB;AAC5B,SACIC,mBAAmB,EACnBC,sBAAsB,EACtBC,mBAAmB,EACnBC,yBAAyB,EACzBC,wBAAwB;AAE5B,SAASC,uBAAuB,EAAEC,sBAAsB","ignoreList":[]}

package/features/tenancy/DeleteTenant/DeleteTenantGateway.d.ts

@@ -0,0 +1,8 @@
+import { DeleteTenantGateway as GatewayAbstraction } from "./abstractions.js";
+import { TenancyStorageOperations } from "../shared/storageOperations.js";
+export declare class DeleteTenantGatewayImpl implements GatewayAbstraction.Interface {
+    private storageOperations;
+    constructor(storageOperations: TenancyStorageOperations.Interface);
+    deleteTenant(id: string): Promise<void>;
+}
+export declare const DeleteTenantGateway: import("@webiny/di").Implementation<typeof DeleteTenantGatewayImpl>;

package/features/tenancy/DeleteTenant/DeleteTenantGateway.js

@@ -0,0 +1,18 @@
+import { createImplementation } from "@webiny/feature/api";
+import { DeleteTenantGateway as GatewayAbstraction } from "./abstractions.js";
+import { TenancyStorageOperations } from "../shared/storageOperations.js";
+export class DeleteTenantGatewayImpl {
+  constructor(storageOperations) {
+    this.storageOperations = storageOperations;
+  }
+  async deleteTenant(id) {
+    return await this.storageOperations.deleteTenant(id);
+  }
+}
+export const DeleteTenantGateway = createImplementation({
+  abstraction: GatewayAbstraction,
+  implementation: DeleteTenantGatewayImpl,
+  dependencies: [TenancyStorageOperations]
+});
+
+//# sourceMappingURL=DeleteTenantGateway.js.map

package/features/tenancy/DeleteTenant/DeleteTenantGateway.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","DeleteTenantGateway","GatewayAbstraction","TenancyStorageOperations","DeleteTenantGatewayImpl","constructor","storageOperations","deleteTenant","id","abstraction","implementation","dependencies"],"sources":["DeleteTenantGateway.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { DeleteTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport { TenancyStorageOperations } from \"../shared/storageOperations.js\";\n\nexport class DeleteTenantGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private storageOperations: TenancyStorageOperations.Interface) {}\n\n    async deleteTenant(id: string): Promise<void> {\n        return await this.storageOperations.deleteTenant(id);\n    }\n}\n\nexport const DeleteTenantGateway = createImplementation({\n    abstraction: GatewayAbstraction,\n    implementation: DeleteTenantGatewayImpl,\n    dependencies: [TenancyStorageOperations]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,mBAAmB,IAAIC,kBAAkB;AAClD,SAASC,wBAAwB;AAEjC,OAAO,MAAMC,uBAAuB,CAAyC;EACzEC,WAAWA,CAASC,iBAAqD,EAAE;IAAA,KAAvDA,iBAAqD,GAArDA,iBAAqD;EAAG;EAE5E,MAAMC,YAAYA,CAACC,EAAU,EAAiB;IAC1C,OAAO,MAAM,IAAI,CAACF,iBAAiB,CAACC,YAAY,CAACC,EAAE,CAAC;EACxD;AACJ;AAEA,OAAO,MAAMP,mBAAmB,GAAGD,oBAAoB,CAAC;EACpDS,WAAW,EAAEP,kBAAkB;EAC/BQ,cAAc,EAAEN,uBAAuB;EACvCO,YAAY,EAAE,CAACR,wBAAwB;AAC3C,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/DeleteTenant/DeleteTenantRepository.d.ts

@@ -0,0 +1,11 @@
+import { DeleteTenantRepository as RepositoryAbstraction } from "./abstractions.js";
+import { DeleteTenantGateway } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+export declare class DeleteTenantRepositoryImpl implements RepositoryAbstraction.Interface {
+    private gateway;
+    private cache;
+    constructor(gateway: DeleteTenantGateway.Interface, cache: TenantCache.Interface);
+    getById(id: string): Promise<import("../InstallTenant/abstractions.js").Tenant>;
+    delete(id: string): Promise<void>;
+}
+export declare const DeleteTenantRepository: import("@webiny/di").Implementation<typeof DeleteTenantRepositoryImpl>;

package/features/tenancy/DeleteTenant/DeleteTenantRepository.js

@@ -0,0 +1,25 @@
+import { createImplementation } from "@webiny/feature/api";
+import { DeleteTenantRepository as RepositoryAbstraction } from "./abstractions.js";
+import { DeleteTenantGateway } from "./abstractions.js";
+import { TenantCache } from "../shared/abstractions.js";
+export class DeleteTenantRepositoryImpl {
+  constructor(gateway, cache) {
+    this.gateway = gateway;
+    this.cache = cache;
+  }
+  async getById(id) {
+    return await this.cache.get(id);
+  }
+  async delete(id) {
+    await this.gateway.deleteTenant(id);
+    this.cache.clear(id);
+    this.cache.prime(id, undefined);
+  }
+}
+export const DeleteTenantRepository = createImplementation({
+  abstraction: RepositoryAbstraction,
+  implementation: DeleteTenantRepositoryImpl,
+  dependencies: [DeleteTenantGateway, TenantCache]
+});
+
+//# sourceMappingURL=DeleteTenantRepository.js.map

package/features/tenancy/DeleteTenant/DeleteTenantRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","DeleteTenantRepository","RepositoryAbstraction","DeleteTenantGateway","TenantCache","DeleteTenantRepositoryImpl","constructor","gateway","cache","getById","id","get","delete","deleteTenant","clear","prime","undefined","abstraction","implementation","dependencies"],"sources":["DeleteTenantRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { DeleteTenantRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { DeleteTenantGateway } from \"./abstractions.js\";\nimport { TenantCache } from \"../shared/abstractions.js\";\n\nexport class DeleteTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: DeleteTenantGateway.Interface,\n        private cache: TenantCache.Interface\n    ) {}\n\n    async getById(id: string) {\n        return await this.cache.get(id);\n    }\n\n    async delete(id: string): Promise<void> {\n        await this.gateway.deleteTenant(id);\n        this.cache.clear(id);\n        this.cache.prime(id, undefined);\n    }\n}\n\nexport const DeleteTenantRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: DeleteTenantRepositoryImpl,\n    dependencies: [DeleteTenantGateway, TenantCache]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,sBAAsB,IAAIC,qBAAqB;AACxD,SAASC,mBAAmB;AAC5B,SAASC,WAAW;AAEpB,OAAO,MAAMC,0BAA0B,CAA4C;EAC/EC,WAAWA,CACCC,OAAsC,EACtCC,KAA4B,EACtC;IAAA,KAFUD,OAAsC,GAAtCA,OAAsC;IAAA,KACtCC,KAA4B,GAA5BA,KAA4B;EACrC;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAE;IACtB,OAAO,MAAM,IAAI,CAACF,KAAK,CAACG,GAAG,CAACD,EAAE,CAAC;EACnC;EAEA,MAAME,MAAMA,CAACF,EAAU,EAAiB;IACpC,MAAM,IAAI,CAACH,OAAO,CAACM,YAAY,CAACH,EAAE,CAAC;IACnC,IAAI,CAACF,KAAK,CAACM,KAAK,CAACJ,EAAE,CAAC;IACpB,IAAI,CAACF,KAAK,CAACO,KAAK,CAACL,EAAE,EAAEM,SAAS,CAAC;EACnC;AACJ;AAEA,OAAO,MAAMf,sBAAsB,GAAGD,oBAAoB,CAAC;EACvDiB,WAAW,EAAEf,qBAAqB;EAClCgB,cAAc,EAAEb,0BAA0B;EAC1Cc,YAAY,EAAE,CAAChB,mBAAmB,EAAEC,WAAW;AACnD,CAAC,CAAC","ignoreList":[]}

package/features/tenancy/DeleteTenant/DeleteTenantUseCase.d.ts

@@ -0,0 +1,12 @@
+import { EventPublisher } from "../../../features/eventPublisher/index.js";
+import { DeleteTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { DeleteTenantRepository } from "./abstractions.js";
+import { GetTenantByIdUseCase } from "../../../features/tenancy/GetTenantById/index.js";
+export declare class DeleteTenantUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getTenantById;
+    private eventPublisher;
+    private repository;
+    constructor(getTenantById: GetTenantByIdUseCase.Interface, eventPublisher: EventPublisher.Interface, repository: DeleteTenantRepository.Interface);
+    execute(id: string): Promise<boolean>;
+}
+export declare const DeleteTenantUseCase: import("@webiny/di").Implementation<typeof DeleteTenantUseCaseImpl>;

package/features/tenancy/DeleteTenant/DeleteTenantUseCase.js

@@ -0,0 +1,35 @@
+import { createImplementation } from "@webiny/di";
+import { EventPublisher } from "../../eventPublisher/index.js";
+import { DeleteTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import { DeleteTenantRepository } from "./abstractions.js";
+import { TenantBeforeDeleteEvent, TenantAfterDeleteEvent } from "./events.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/index.js";
+export class DeleteTenantUseCaseImpl {
+  constructor(getTenantById, eventPublisher, repository) {
+    this.getTenantById = getTenantById;
+    this.eventPublisher = eventPublisher;
+    this.repository = repository;
+  }
+  async execute(id) {
+    const result = await this.getTenantById.execute(id);
+    if (result.isFail()) {
+      return false;
+    }
+    const tenant = result.value;
+    await this.eventPublisher.publish(new TenantBeforeDeleteEvent({
+      tenant
+    }));
+    await this.repository.delete(id);
+    await this.eventPublisher.publish(new TenantAfterDeleteEvent({
+      tenant
+    }));
+    return true;
+  }
+}
+export const DeleteTenantUseCase = createImplementation({
+  abstraction: UseCaseAbstraction,
+  implementation: DeleteTenantUseCaseImpl,
+  dependencies: [GetTenantByIdUseCase, EventPublisher, DeleteTenantRepository]
+});
+
+//# sourceMappingURL=DeleteTenantUseCase.js.map

package/features/tenancy/DeleteTenant/DeleteTenantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","EventPublisher","DeleteTenantUseCase","UseCaseAbstraction","DeleteTenantRepository","TenantBeforeDeleteEvent","TenantAfterDeleteEvent","GetTenantByIdUseCase","DeleteTenantUseCaseImpl","constructor","getTenantById","eventPublisher","repository","execute","id","result","isFail","tenant","value","publish","delete","abstraction","implementation","dependencies"],"sources":["DeleteTenantUseCase.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/di\";\nimport { EventPublisher } from \"~/features/eventPublisher/index.js\";\nimport { DeleteTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { DeleteTenantRepository } from \"./abstractions.js\";\nimport { TenantBeforeDeleteEvent, TenantAfterDeleteEvent } from \"./events.js\";\nimport { GetTenantByIdUseCase } from \"~/features/tenancy/GetTenantById/index.js\";\n\nexport class DeleteTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getTenantById: GetTenantByIdUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: DeleteTenantRepository.Interface\n    ) {}\n\n    async execute(id: string): Promise<boolean> {\n        const result = await this.getTenantById.execute(id);\n\n        if (result.isFail()) {\n            return false;\n        }\n\n        const tenant = result.value;\n\n        await this.eventPublisher.publish(new TenantBeforeDeleteEvent({ tenant }));\n\n        await this.repository.delete(id);\n\n        await this.eventPublisher.publish(new TenantAfterDeleteEvent({ tenant }));\n\n        return true;\n    }\n}\n\nexport const DeleteTenantUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: DeleteTenantUseCaseImpl,\n    dependencies: [GetTenantByIdUseCase, EventPublisher, DeleteTenantRepository]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,YAAY;AACjD,SAASC,cAAc;AACvB,SAASC,mBAAmB,IAAIC,kBAAkB;AAClD,SAASC,sBAAsB;AAC/B,SAASC,uBAAuB,EAAEC,sBAAsB;AACxD,SAASC,oBAAoB;AAE7B,OAAO,MAAMC,uBAAuB,CAAyC;EACzEC,WAAWA,CACCC,aAA6C,EAC7CC,cAAwC,EACxCC,UAA4C,EACtD;IAAA,KAHUF,aAA6C,GAA7CA,aAA6C;IAAA,KAC7CC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,UAA4C,GAA5CA,UAA4C;EACrD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAoB;IACxC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACL,aAAa,CAACG,OAAO,CAACC,EAAE,CAAC;IAEnD,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAO,KAAK;IAChB;IAEA,MAAMC,MAAM,GAAGF,MAAM,CAACG,KAAK;IAE3B,MAAM,IAAI,CAACP,cAAc,CAACQ,OAAO,CAAC,IAAId,uBAAuB,CAAC;MAAEY;IAAO,CAAC,CAAC,CAAC;IAE1E,MAAM,IAAI,CAACL,UAAU,CAACQ,MAAM,CAACN,EAAE,CAAC;IAEhC,MAAM,IAAI,CAACH,cAAc,CAACQ,OAAO,CAAC,IAAIb,sBAAsB,CAAC;MAAEW;IAAO,CAAC,CAAC,CAAC;IAEzE,OAAO,IAAI;EACf;AACJ;AAEA,OAAO,MAAMf,mBAAmB,GAAGF,oBAAoB,CAAC;EACpDqB,WAAW,EAAElB,kBAAkB;EAC/BmB,cAAc,EAAEd,uBAAuB;EACvCe,YAAY,EAAE,CAAChB,oBAAoB,EAAEN,cAAc,EAAEG,sBAAsB;AAC/E,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,33 @@
+import type { IEventHandler, DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { TenantBeforeDeletePayload, TenantAfterDeletePayload } from "./events.js";
+export interface IDeleteTenantUseCase {
+    execute(id: string): Promise<boolean>;
+}
+export declare const DeleteTenantUseCase: import("@webiny/di").Abstraction<IDeleteTenantUseCase>;
+export declare namespace DeleteTenantUseCase {
+    type Interface = IDeleteTenantUseCase;
+}
+export interface IDeleteTenantRepository {
+    delete(id: string): Promise<void>;
+}
+export declare const DeleteTenantRepository: import("@webiny/di").Abstraction<IDeleteTenantRepository>;
+export declare namespace DeleteTenantRepository {
+    type Interface = IDeleteTenantRepository;
+}
+export interface IDeleteTenantGateway {
+    deleteTenant(id: string): Promise<void>;
+}
+export declare const DeleteTenantGateway: import("@webiny/di").Abstraction<IDeleteTenantGateway>;
+export declare namespace DeleteTenantGateway {
+    type Interface = IDeleteTenantGateway;
+}
+export declare const TenantBeforeDeleteHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantBeforeDeletePayload>>>;
+export declare namespace TenantBeforeDeleteHandler {
+    type Interface = IEventHandler<DomainEvent<TenantBeforeDeletePayload>>;
+    type Event = DomainEvent<TenantBeforeDeletePayload>;
+}
+export declare const TenantAfterDeleteHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantAfterDeletePayload>>>;
+export declare namespace TenantAfterDeleteHandler {
+    type Interface = IEventHandler<DomainEvent<TenantAfterDeletePayload>>;
+    type Event = DomainEvent<TenantAfterDeletePayload>;
+}

package/features/tenancy/DeleteTenant/abstractions.js

@@ -0,0 +1,8 @@
+import { createAbstraction } from "@webiny/feature/api";
+export const DeleteTenantUseCase = createAbstraction("DeleteTenantUseCase");
+export const DeleteTenantRepository = createAbstraction("DeleteTenantRepository");
+export const DeleteTenantGateway = createAbstraction("DeleteTenantGateway");
+export const TenantBeforeDeleteHandler = createAbstraction("TenantBeforeDeleteHandler");
+export const TenantAfterDeleteHandler = createAbstraction("TenantAfterDeleteHandler");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DeleteTenantUseCase","DeleteTenantRepository","DeleteTenantGateway","TenantBeforeDeleteHandler","TenantAfterDeleteHandler"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler, DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { TenantBeforeDeletePayload, TenantAfterDeletePayload } from \"./events.js\";\n\nexport interface IDeleteTenantUseCase {\n    execute(id: string): Promise<boolean>;\n}\n\nexport const DeleteTenantUseCase = createAbstraction<IDeleteTenantUseCase>(\"DeleteTenantUseCase\");\n\nexport namespace DeleteTenantUseCase {\n    export type Interface = IDeleteTenantUseCase;\n}\n\nexport interface IDeleteTenantRepository {\n    delete(id: string): Promise<void>;\n}\n\nexport const DeleteTenantRepository =\n    createAbstraction<IDeleteTenantRepository>(\"DeleteTenantRepository\");\n\nexport namespace DeleteTenantRepository {\n    export type Interface = IDeleteTenantRepository;\n}\n\nexport interface IDeleteTenantGateway {\n    deleteTenant(id: string): Promise<void>;\n}\n\nexport const DeleteTenantGateway = createAbstraction<IDeleteTenantGateway>(\"DeleteTenantGateway\");\n\nexport namespace DeleteTenantGateway {\n    export type Interface = IDeleteTenantGateway;\n}\n\nexport const TenantBeforeDeleteHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantBeforeDeletePayload>>\n>(\"TenantBeforeDeleteHandler\");\n\nexport namespace TenantBeforeDeleteHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantBeforeDeletePayload>>;\n    export type Event = DomainEvent<TenantBeforeDeletePayload>;\n}\n\nexport const TenantAfterDeleteHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantAfterDeletePayload>>\n>(\"TenantAfterDeleteHandler\");\n\nexport namespace TenantAfterDeleteHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantAfterDeletePayload>>;\n    export type Event = DomainEvent<TenantAfterDeletePayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAQvD,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAAuB,qBAAqB,CAAC;AAUjG,OAAO,MAAME,sBAAsB,GAC/BF,iBAAiB,CAA0B,wBAAwB,CAAC;AAUxE,OAAO,MAAMG,mBAAmB,GAAGH,iBAAiB,CAAuB,qBAAqB,CAAC;AAMjG,OAAO,MAAMI,yBAAyB,GAAGJ,iBAAiB,CAExD,2BAA2B,CAAC;AAO9B,OAAO,MAAMK,wBAAwB,GAAGL,iBAAiB,CAEvD,0BAA0B,CAAC","ignoreList":[]}

package/features/tenancy/DeleteTenant/decorators/DeleteTenantWithWcpDecrement.d.ts

@@ -0,0 +1,10 @@
+import { DeleteTenantUseCase } from "../abstractions.js";
+import { WcpContext } from "../../../../features/wcp/WcpContext/index.js";
+declare class DeleteTenantWithWcpDecrementImpl implements DeleteTenantUseCase.Interface {
+    private wcp;
+    private decoratee;
+    constructor(wcp: WcpContext.Interface, decoratee: DeleteTenantUseCase.Interface);
+    execute(id: string): Promise<boolean>;
+}
+export declare const DeleteTenantWithWcpDecrement: typeof DeleteTenantWithWcpDecrementImpl;
+export {};

package/features/tenancy/DeleteTenant/decorators/DeleteTenantWithWcpDecrement.js

@@ -0,0 +1,21 @@
+import { createDecorator } from "@webiny/feature/api";
+import { DeleteTenantUseCase } from "../abstractions.js";
+import { WcpContext } from "../../../wcp/WcpContext/index.js";
+class DeleteTenantWithWcpDecrementImpl {
+  constructor(wcp, decoratee) {
+    this.wcp = wcp;
+    this.decoratee = decoratee;
+  }
+  async execute(id) {
+    const result = await this.decoratee.execute(id);
+    await this.wcp.decrementTenants();
+    return result;
+  }
+}
+export const DeleteTenantWithWcpDecrement = createDecorator({
+  abstraction: DeleteTenantUseCase,
+  decorator: DeleteTenantWithWcpDecrementImpl,
+  dependencies: [WcpContext]
+});
+
+//# sourceMappingURL=DeleteTenantWithWcpDecrement.js.map

package/features/tenancy/DeleteTenant/decorators/DeleteTenantWithWcpDecrement.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createDecorator","DeleteTenantUseCase","WcpContext","DeleteTenantWithWcpDecrementImpl","constructor","wcp","decoratee","execute","id","result","decrementTenants","DeleteTenantWithWcpDecrement","abstraction","decorator","dependencies"],"sources":["DeleteTenantWithWcpDecrement.ts"],"sourcesContent":["import { createDecorator } from \"@webiny/feature/api\";\nimport { DeleteTenantUseCase } from \"../abstractions.js\";\nimport { WcpContext } from \"~/features/wcp/WcpContext/index.js\";\n\nclass DeleteTenantWithWcpDecrementImpl implements DeleteTenantUseCase.Interface {\n    constructor(\n        private wcp: WcpContext.Interface,\n        private decoratee: DeleteTenantUseCase.Interface\n    ) {}\n\n    async execute(id: string): Promise<boolean> {\n        const result = await this.decoratee.execute(id);\n        await this.wcp.decrementTenants();\n        return result;\n    }\n}\n\nexport const DeleteTenantWithWcpDecrement = createDecorator({\n    abstraction: DeleteTenantUseCase,\n    decorator: DeleteTenantWithWcpDecrementImpl,\n    dependencies: [WcpContext]\n});\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,qBAAqB;AACrD,SAASC,mBAAmB;AAC5B,SAASC,UAAU;AAEnB,MAAMC,gCAAgC,CAA0C;EAC5EC,WAAWA,CACCC,GAAyB,EACzBC,SAAwC,EAClD;IAAA,KAFUD,GAAyB,GAAzBA,GAAyB;IAAA,KACzBC,SAAwC,GAAxCA,SAAwC;EACjD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAoB;IACxC,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACH,SAAS,CAACC,OAAO,CAACC,EAAE,CAAC;IAC/C,MAAM,IAAI,CAACH,GAAG,CAACK,gBAAgB,CAAC,CAAC;IACjC,OAAOD,MAAM;EACjB;AACJ;AAEA,OAAO,MAAME,4BAA4B,GAAGX,eAAe,CAAC;EACxDY,WAAW,EAAEX,mBAAmB;EAChCY,SAAS,EAAEV,gCAAgC;EAC3CW,YAAY,EAAE,CAACZ,UAAU;AAC7B,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,16 @@
+import { DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+export interface TenantBeforeDeletePayload {
+    tenant: Tenant;
+}
+export interface TenantAfterDeletePayload {
+    tenant: Tenant;
+}
+export declare class TenantBeforeDeleteEvent extends DomainEvent<TenantBeforeDeletePayload> {
+    eventType: "tenant.beforeDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantBeforeDeletePayload>>>;
+}
+export declare class TenantAfterDeleteEvent extends DomainEvent<TenantAfterDeletePayload> {
+    eventType: "tenant.afterDelete";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<import("~/features/eventPublisher/index.js").IEventHandler<DomainEvent<TenantAfterDeletePayload>>>;
+}

package/features/tenancy/DeleteTenant/events.js

@@ -0,0 +1,16 @@
+import { DomainEvent } from "../../eventPublisher/index.js";
+import { TenantBeforeDeleteHandler, TenantAfterDeleteHandler } from "./abstractions.js";
+export class TenantBeforeDeleteEvent extends DomainEvent {
+  eventType = "tenant.beforeDelete";
+  getHandlerAbstraction() {
+    return TenantBeforeDeleteHandler;
+  }
+}
+export class TenantAfterDeleteEvent extends DomainEvent {
+  eventType = "tenant.afterDelete";
+  getHandlerAbstraction() {
+    return TenantAfterDeleteHandler;
+  }
+}
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TenantBeforeDeleteHandler","TenantAfterDeleteHandler","TenantBeforeDeleteEvent","eventType","getHandlerAbstraction","TenantAfterDeleteEvent"],"sources":["events.ts"],"sourcesContent":["import { DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { TenantBeforeDeleteHandler, TenantAfterDeleteHandler } from \"./abstractions.js\";\n\nexport interface TenantBeforeDeletePayload {\n    tenant: Tenant;\n}\n\nexport interface TenantAfterDeletePayload {\n    tenant: Tenant;\n}\n\nexport class TenantBeforeDeleteEvent extends DomainEvent<TenantBeforeDeletePayload> {\n    eventType = \"tenant.beforeDelete\" as const;\n\n    getHandlerAbstraction() {\n        return TenantBeforeDeleteHandler;\n    }\n}\n\nexport class TenantAfterDeleteEvent extends DomainEvent<TenantAfterDeletePayload> {\n    eventType = \"tenant.afterDelete\" as const;\n\n    getHandlerAbstraction() {\n        return TenantAfterDeleteHandler;\n    }\n}\n"],"mappings":"AAAA,SAASA,WAAW;AAEpB,SAASC,yBAAyB,EAAEC,wBAAwB;AAU5D,OAAO,MAAMC,uBAAuB,SAASH,WAAW,CAA4B;EAChFI,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOJ,yBAAyB;EACpC;AACJ;AAEA,OAAO,MAAMK,sBAAsB,SAASN,WAAW,CAA2B;EAC9EI,SAAS,GAAG,oBAAoB;EAEhCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOH,wBAAwB;EACnC;AACJ","ignoreList":[]}

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

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