@webiny/api-core 0.0.0-unstable.61c048f412

package/features/tenancy/ListTenants/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ListTenantsUseCase","ListTenantsRepository","ListTenantsGateway"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { Tenant, ListTenantsParams } from \"~/types/tenancy.js\";\n\n// Use Case Abstraction\nexport interface IListTenantsUseCase {\n    execute(params?: ListTenantsParams): Promise<Result<Tenant[]>>;\n}\n\nexport const ListTenantsUseCase = createAbstraction<IListTenantsUseCase>(\"ListTenantsUseCase\");\n\nexport namespace ListTenantsUseCase {\n    export type Interface = IListTenantsUseCase;\n}\n\n// Repository Abstraction\nexport interface IListTenantsRepository {\n    list(params?: ListTenantsParams): Promise<Tenant[]>;\n}\n\nexport const ListTenantsRepository =\n    createAbstraction<IListTenantsRepository>(\"ListTenantsRepository\");\n\nexport namespace ListTenantsRepository {\n    export type Interface = IListTenantsRepository;\n}\n\n// Gateway Abstraction\nexport interface IListTenantsGateway {\n    listTenants(params?: ListTenantsParams): Promise<Tenant[]>;\n}\n\nexport const ListTenantsGateway = createAbstraction<IListTenantsGateway>(\"ListTenantsGateway\");\n\nexport namespace ListTenantsGateway {\n    export type Interface = IListTenantsGateway;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAgB,qBAAqB;;AAG/D;;AAKA,OAAO,MAAMC,kBAAkB,GAAGD,iBAAiB,CAAsB,oBAAoB,CAAC;;AAM9F;;AAKA,OAAO,MAAME,qBAAqB,GAC9BF,iBAAiB,CAAyB,uBAAuB,CAAC;;AAMtE;;AAKA,OAAO,MAAMG,kBAAkB,GAAGH,iBAAiB,CAAsB,oBAAoB,CAAC","ignoreList":[]}

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

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

package/features/tenancy/ListTenants/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ListTenantsUseCase","ListTenantsRepository","ListTenantsGateway","ListTenantsFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { ListTenantsUseCase } from \"./ListTenantsUseCase.js\";\nimport { ListTenantsRepository } from \"./ListTenantsRepository.js\";\nimport { ListTenantsGateway } from \"./ListTenantsGateway.js\";\n\nexport const ListTenantsFeature = createFeature({\n    name: \"ListTenants\",\n    register(container: Container) {\n        container.register(ListTenantsUseCase);\n        container.register(ListTenantsRepository).inSingletonScope();\n        container.register(ListTenantsGateway).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,kBAAkB;AAC3B,SAASC,qBAAqB;AAC9B,SAASC,kBAAkB;AAE3B,OAAO,MAAMC,kBAAkB,GAAGJ,aAAa,CAAC;EAC5CK,IAAI,EAAE,aAAa;EACnBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,kBAAkB,CAAC;IACtCM,SAAS,CAACD,QAAQ,CAACJ,qBAAqB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC5DD,SAAS,CAACD,QAAQ,CAACH,kBAAkB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAC7D;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/tenancy/ListTenants/index.js

@@ -0,0 +1,4 @@
+export { ListTenantsFeature } from "./feature.js";
+export { ListTenantsUseCase, ListTenantsRepository, ListTenantsGateway } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["ListTenantsFeature","ListTenantsUseCase","ListTenantsRepository","ListTenantsGateway"],"sources":["index.ts"],"sourcesContent":["export { ListTenantsFeature } from \"./feature.js\";\nexport { ListTenantsUseCase, ListTenantsRepository, ListTenantsGateway } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,kBAAkB;AAC3B,SAASC,kBAAkB,EAAEC,qBAAqB,EAAEC,kBAAkB","ignoreList":[]}

package/features/tenancy/TenancyFeature.d.ts

@@ -0,0 +1,2 @@
+import type { TenancyStorageOperations as ITenancyStorageOperations } from "../../types/tenancy.js";
+export declare const TenancyFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<ITenancyStorageOperations>;

package/features/tenancy/TenancyFeature.js

@@ -0,0 +1,40 @@
+import { createFeature } from "@webiny/feature/api";
+import { TenantCache } from "./shared/abstractions.js";
+import { TenantCache as TenantCacheImpl } from "./shared/TenantCache.js";
+import { TenancyStorageOperations } from "./shared/storageOperations.js";
+import { GetRootTenantFeature } from "./GetRootTenant/feature.js";
+import { ListTenantsFeature } from "./ListTenants/feature.js";
+import { CreateTenantFeature } from "./CreateTenant/feature.js";
+import { UpdateTenantFeature } from "./UpdateTenant/feature.js";
+import { DeleteTenantFeature } from "./DeleteTenant/feature.js";
+import { GetTenantByIdFeature } from "./GetTenantById/feature.js";
+import { TenantContextFeature } from "./TenantContext/feature.js";
+import { InstallTenantFeature } from "./InstallTenant/index.js";
+export const TenancyFeature = createFeature({
+  name: "TenancyFeature",
+  register: (container, storageOperations) => {
+    // Register storage operations abstraction (singleton)
+    container.registerInstance(TenancyStorageOperations, storageOperations);
+
+    // Register shared cache (singleton) - batch loader provided here
+    container.registerInstance(TenantCache, new TenantCacheImpl(async ids => {
+      if (ids.length === 0) {
+        return [];
+      }
+      const tenants = await storageOperations.getTenantsByIds(ids);
+      return ids.map((_, index) => tenants[index]);
+    }));
+
+    // Register all features - they will auto-wire their dependencies from the container
+    CreateTenantFeature.register(container);
+    DeleteTenantFeature.register(container);
+    GetRootTenantFeature.register(container);
+    GetTenantByIdFeature.register(container);
+    ListTenantsFeature.register(container);
+    UpdateTenantFeature.register(container);
+    TenantContextFeature.register(container);
+    InstallTenantFeature.register(container);
+  }
+});
+
+//# sourceMappingURL=TenancyFeature.js.map

package/features/tenancy/TenancyFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","TenantCache","TenantCacheImpl","TenancyStorageOperations","GetRootTenantFeature","ListTenantsFeature","CreateTenantFeature","UpdateTenantFeature","DeleteTenantFeature","GetTenantByIdFeature","TenantContextFeature","InstallTenantFeature","TenancyFeature","name","register","container","storageOperations","registerInstance","ids","length","tenants","getTenantsByIds","map","_","index"],"sources":["TenancyFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { TenancyStorageOperations as ITenancyStorageOperations } from \"~/types/tenancy.js\";\nimport { TenantCache } from \"./shared/abstractions.js\";\nimport { TenantCache as TenantCacheImpl } from \"./shared/TenantCache.js\";\nimport { TenancyStorageOperations } from \"./shared/storageOperations.js\";\nimport { GetRootTenantFeature } from \"./GetRootTenant/feature.js\";\nimport { ListTenantsFeature } from \"./ListTenants/feature.js\";\nimport { CreateTenantFeature } from \"./CreateTenant/feature.js\";\nimport { UpdateTenantFeature } from \"./UpdateTenant/feature.js\";\nimport { DeleteTenantFeature } from \"./DeleteTenant/feature.js\";\nimport { GetTenantByIdFeature } from \"./GetTenantById/feature.js\";\nimport { TenantContextFeature } from \"./TenantContext/feature.js\";\nimport { InstallTenantFeature } from \"./InstallTenant/index.js\";\n\nexport const TenancyFeature = createFeature({\n    name: \"TenancyFeature\",\n    register: (container, storageOperations: ITenancyStorageOperations) => {\n        // Register storage operations abstraction (singleton)\n        container.registerInstance(TenancyStorageOperations, storageOperations);\n\n        // Register shared cache (singleton) - batch loader provided here\n        container.registerInstance(\n            TenantCache,\n            new TenantCacheImpl(async (ids: readonly string[]) => {\n                if (ids.length === 0) {\n                    return [];\n                }\n                const tenants = await storageOperations.getTenantsByIds(ids);\n                return ids.map((_, index) => tenants[index]);\n            })\n        );\n\n        // Register all features - they will auto-wire their dependencies from the container\n        CreateTenantFeature.register(container);\n        DeleteTenantFeature.register(container);\n        GetRootTenantFeature.register(container);\n        GetTenantByIdFeature.register(container);\n        ListTenantsFeature.register(container);\n        UpdateTenantFeature.register(container);\n        TenantContextFeature.register(container);\n        InstallTenantFeature.register(container);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,WAAW;AACpB,SAASA,WAAW,IAAIC,eAAe;AACvC,SAASC,wBAAwB;AACjC,SAASC,oBAAoB;AAC7B,SAASC,kBAAkB;AAC3B,SAASC,mBAAmB;AAC5B,SAASC,mBAAmB;AAC5B,SAASC,mBAAmB;AAC5B,SAASC,oBAAoB;AAC7B,SAASC,oBAAoB;AAC7B,SAASC,oBAAoB;AAE7B,OAAO,MAAMC,cAAc,GAAGZ,aAAa,CAAC;EACxCa,IAAI,EAAE,gBAAgB;EACtBC,QAAQ,EAAEA,CAACC,SAAS,EAAEC,iBAA4C,KAAK;IACnE;IACAD,SAAS,CAACE,gBAAgB,CAACd,wBAAwB,EAAEa,iBAAiB,CAAC;;IAEvE;IACAD,SAAS,CAACE,gBAAgB,CACtBhB,WAAW,EACX,IAAIC,eAAe,CAAC,MAAOgB,GAAsB,IAAK;MAClD,IAAIA,GAAG,CAACC,MAAM,KAAK,CAAC,EAAE;QAClB,OAAO,EAAE;MACb;MACA,MAAMC,OAAO,GAAG,MAAMJ,iBAAiB,CAACK,eAAe,CAACH,GAAG,CAAC;MAC5D,OAAOA,GAAG,CAACI,GAAG,CAAC,CAACC,CAAC,EAAEC,KAAK,KAAKJ,OAAO,CAACI,KAAK,CAAC,CAAC;IAChD,CAAC,CACL,CAAC;;IAED;IACAlB,mBAAmB,CAACQ,QAAQ,CAACC,SAAS,CAAC;IACvCP,mBAAmB,CAACM,QAAQ,CAACC,SAAS,CAAC;IACvCX,oBAAoB,CAACU,QAAQ,CAACC,SAAS,CAAC;IACxCN,oBAAoB,CAACK,QAAQ,CAACC,SAAS,CAAC;IACxCV,kBAAkB,CAACS,QAAQ,CAACC,SAAS,CAAC;IACtCR,mBAAmB,CAACO,QAAQ,CAACC,SAAS,CAAC;IACvCL,oBAAoB,CAACI,QAAQ,CAACC,SAAS,CAAC;IACxCJ,oBAAoB,CAACG,QAAQ,CAACC,SAAS,CAAC;EAC5C;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/tenancy/TenantContext/TenantContext.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","TenantContext","Abstraction","GetRootTenantUseCase","TenantIsDisabledError","TenantContextImpl","currentTenant","constructor","getRootTenant","getTenant","setTenant","tenant","isInstalled","status","withRootTenant","cb","initialTenant","rootTenant","execute","isOk","error","value","withEachTenant","tenants","results","push","withTenant","result","abstraction","implementation","dependencies"],"sources":["TenantContext.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { TenantContext as Abstraction } from \"./abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { GetRootTenantUseCase } from \"~/features/tenancy/GetRootTenant/index.js\";\nimport { TenantIsDisabledError } from \"./errors.js\";\n\nclass TenantContextImpl implements Abstraction.Interface {\n    private currentTenant: Tenant | null = null;\n\n    constructor(private getRootTenant: GetRootTenantUseCase.Interface) {}\n\n    getTenant(): Tenant {\n        return this.currentTenant!;\n    }\n\n    setTenant(tenant: Tenant): void {\n        if (tenant.isInstalled && tenant.status === \"disabled\") {\n            throw new TenantIsDisabledError();\n        }\n        this.currentTenant = tenant;\n    }\n\n    async withRootTenant<T>(cb: () => T): Promise<T> {\n        const initialTenant = this.getTenant();\n        const rootTenant = await this.getRootTenant.execute();\n        if (!rootTenant.isOk()) {\n            return rootTenant.error as T;\n        }\n\n        const tenant = rootTenant.value as Tenant;\n\n        this.setTenant(tenant);\n        try {\n            return await cb();\n        } finally {\n            // Make sure that, whatever happens in the callback, the tenant is set back to the initial one.\n            this.setTenant(initialTenant);\n        }\n    }\n\n    async withEachTenant<TReturn>(\n        tenants: Tenant[],\n        cb: (tenant: Tenant) => Promise<TReturn>\n    ): Promise<TReturn[]> {\n        const initialTenant = this.getTenant();\n        const results = [];\n        for (const tenant of tenants) {\n            this.setTenant(tenant);\n            try {\n                results.push(await cb(tenant));\n            } finally {\n                this.setTenant(initialTenant);\n            }\n        }\n        return results;\n    }\n\n    async withTenant<TReturn>(\n        tenant: Tenant,\n        cb: (tenant: Tenant) => Promise<TReturn>\n    ): Promise<TReturn> {\n        const initialTenant = this.getTenant();\n        this.setTenant(tenant);\n        const result = await cb(tenant);\n        this.setTenant(initialTenant);\n        return result;\n    }\n}\n\nexport const TenantContext = createImplementation({\n    abstraction: Abstraction,\n    implementation: TenantContextImpl,\n    dependencies: [GetRootTenantUseCase]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,aAAa,IAAIC,WAAW;AAErC,SAASC,oBAAoB;AAC7B,SAASC,qBAAqB;AAE9B,MAAMC,iBAAiB,CAAkC;EAC7CC,aAAa,GAAkB,IAAI;EAE3CC,WAAWA,CAASC,aAA6C,EAAE;IAAA,KAA/CA,aAA6C,GAA7CA,aAA6C;EAAG;EAEpEC,SAASA,CAAA,EAAW;IAChB,OAAO,IAAI,CAACH,aAAa;EAC7B;EAEAI,SAASA,CAACC,MAAc,EAAQ;IAC5B,IAAIA,MAAM,CAACC,WAAW,IAAID,MAAM,CAACE,MAAM,KAAK,UAAU,EAAE;MACpD,MAAM,IAAIT,qBAAqB,CAAC,CAAC;IACrC;IACA,IAAI,CAACE,aAAa,GAAGK,MAAM;EAC/B;EAEA,MAAMG,cAAcA,CAAIC,EAAW,EAAc;IAC7C,MAAMC,aAAa,GAAG,IAAI,CAACP,SAAS,CAAC,CAAC;IACtC,MAAMQ,UAAU,GAAG,MAAM,IAAI,CAACT,aAAa,CAACU,OAAO,CAAC,CAAC;IACrD,IAAI,CAACD,UAAU,CAACE,IAAI,CAAC,CAAC,EAAE;MACpB,OAAOF,UAAU,CAACG,KAAK;IAC3B;IAEA,MAAMT,MAAM,GAAGM,UAAU,CAACI,KAAe;IAEzC,IAAI,CAACX,SAAS,CAACC,MAAM,CAAC;IACtB,IAAI;MACA,OAAO,MAAMI,EAAE,CAAC,CAAC;IACrB,CAAC,SAAS;MACN;MACA,IAAI,CAACL,SAAS,CAACM,aAAa,CAAC;IACjC;EACJ;EAEA,MAAMM,cAAcA,CAChBC,OAAiB,EACjBR,EAAwC,EACtB;IAClB,MAAMC,aAAa,GAAG,IAAI,CAACP,SAAS,CAAC,CAAC;IACtC,MAAMe,OAAO,GAAG,EAAE;IAClB,KAAK,MAAMb,MAAM,IAAIY,OAAO,EAAE;MAC1B,IAAI,CAACb,SAAS,CAACC,MAAM,CAAC;MACtB,IAAI;QACAa,OAAO,CAACC,IAAI,CAAC,MAAMV,EAAE,CAACJ,MAAM,CAAC,CAAC;MAClC,CAAC,SAAS;QACN,IAAI,CAACD,SAAS,CAACM,aAAa,CAAC;MACjC;IACJ;IACA,OAAOQ,OAAO;EAClB;EAEA,MAAME,UAAUA,CACZf,MAAc,EACdI,EAAwC,EACxB;IAChB,MAAMC,aAAa,GAAG,IAAI,CAACP,SAAS,CAAC,CAAC;IACtC,IAAI,CAACC,SAAS,CAACC,MAAM,CAAC;IACtB,MAAMgB,MAAM,GAAG,MAAMZ,EAAE,CAACJ,MAAM,CAAC;IAC/B,IAAI,CAACD,SAAS,CAACM,aAAa,CAAC;IAC7B,OAAOW,MAAM;EACjB;AACJ;AAEA,OAAO,MAAM1B,aAAa,GAAGD,oBAAoB,CAAC;EAC9C4B,WAAW,EAAE1B,WAAW;EACxB2B,cAAc,EAAExB,iBAAiB;EACjCyB,YAAY,EAAE,CAAC3B,oBAAoB;AACvC,CAAC,CAAC","ignoreList":[]}

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

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

package/features/tenancy/TenantContext/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TenantContext"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nexport interface ITenantContext {\n    setTenant(tenant: Tenant): void;\n    getTenant(): Tenant;\n    withRootTenant<T>(cb: () => T): Promise<T>;\n    withEachTenant<TReturn>(\n        tenants: Tenant[],\n        cb: (tenant: Tenant) => Promise<TReturn>\n    ): Promise<TReturn[]>;\n    withTenant<TReturn>(tenant: Tenant, cb: (tenant: Tenant) => Promise<TReturn>): Promise<TReturn>;\n}\n\nexport const TenantContext = createAbstraction<ITenantContext>(\"TenantContext\");\n\nexport namespace TenantContext {\n    export type Interface = ITenantContext;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAcvD,OAAO,MAAMC,aAAa,GAAGD,iBAAiB,CAAiB,eAAe,CAAC","ignoreList":[]}

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

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

package/features/tenancy/TenantContext/errors.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["BaseError","TenantIsDisabledError","code","constructor","message"],"sources":["errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class TenantIsDisabledError extends BaseError {\n    override readonly code = \"Tenancy/TenantDisabled\" as const;\n\n    constructor() {\n        super({ message: \"Tenant is disabled!\" });\n    }\n}\n"],"mappings":"AAAA,SAASA,SAAS,QAAQ,qBAAqB;AAE/C,OAAO,MAAMC,qBAAqB,SAASD,SAAS,CAAC;EAC/BE,IAAI,GAAG,wBAAwB;EAEjDC,WAAWA,CAAA,EAAG;IACV,KAAK,CAAC;MAAEC,OAAO,EAAE;IAAsB,CAAC,CAAC;EAC7C;AACJ","ignoreList":[]}

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

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

package/features/tenancy/TenantContext/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","TenantContext","TenantContextFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { TenantContext } from \"./TenantContext.js\";\n\nexport const TenantContextFeature = createFeature({\n    name: \"TenantContextFeature\",\n    register(container) {\n        container.register(TenantContext).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,aAAa;AAEtB,OAAO,MAAMC,oBAAoB,GAAGF,aAAa,CAAC;EAC9CG,IAAI,EAAE,sBAAsB;EAC5BC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,aAAa,CAAC,CAACK,gBAAgB,CAAC,CAAC;EACxD;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/tenancy/TenantContext/index.js

@@ -0,0 +1,3 @@
+export { TenantContext } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TenantContext"],"sources":["index.ts"],"sourcesContent":["export { TenantContext } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,aAAa","ignoreList":[]}

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

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

package/features/tenancy/UpdateTenant/UpdateTenantGateway.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","UpdateTenantGateway","GatewayAbstraction","TenancyStorageOperations","UpdateTenantGatewayImpl","constructor","storageOperations","updateTenant","data","abstraction","implementation","dependencies"],"sources":["UpdateTenantGateway.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateTenantGateway as GatewayAbstraction } from \"./abstractions.js\";\nimport { type Tenant } from \"~/types/tenancy.js\";\nimport { TenancyStorageOperations } from \"~/features/tenancy/shared/storageOperations.js\";\n\nclass UpdateTenantGatewayImpl implements GatewayAbstraction.Interface {\n    constructor(private storageOperations: TenancyStorageOperations.Interface) {}\n\n    async updateTenant(data: Tenant) {\n        return await this.storageOperations.updateTenant(data);\n    }\n}\n\nexport const UpdateTenantGateway = createImplementation({\n    abstraction: GatewayAbstraction,\n    implementation: UpdateTenantGatewayImpl,\n    dependencies: [TenancyStorageOperations]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,mBAAmB,IAAIC,kBAAkB;AAElD,SAASC,wBAAwB;AAEjC,MAAMC,uBAAuB,CAAyC;EAClEC,WAAWA,CAASC,iBAAqD,EAAE;IAAA,KAAvDA,iBAAqD,GAArDA,iBAAqD;EAAG;EAE5E,MAAMC,YAAYA,CAACC,IAAY,EAAE;IAC7B,OAAO,MAAM,IAAI,CAACF,iBAAiB,CAACC,YAAY,CAACC,IAAI,CAAC;EAC1D;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/UpdateTenant/UpdateTenantRepository.d.ts

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

package/features/tenancy/UpdateTenant/UpdateTenantRepository.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createImplementation","UpdateTenantRepository","RepositoryAbstraction","UpdateTenantGateway","TenantCache","UpdateTenantRepositoryImpl","constructor","gateway","cache","update","tenant","updated","updateTenant","clear","id","prime","abstraction","implementation","dependencies"],"sources":["UpdateTenantRepository.ts"],"sourcesContent":["import { createImplementation } from \"@webiny/feature/api\";\nimport { UpdateTenantRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { UpdateTenantGateway } from \"./abstractions.js\";\nimport { TenantCache } from \"../shared/abstractions.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\n\nclass UpdateTenantRepositoryImpl implements RepositoryAbstraction.Interface {\n    constructor(\n        private gateway: UpdateTenantGateway.Interface,\n        private cache: TenantCache.Interface\n    ) {}\n\n    async update(tenant: Tenant) {\n        const updated = await this.gateway.updateTenant(tenant);\n        this.cache.clear(updated.id);\n        this.cache.prime(updated.id, updated);\n        return updated;\n    }\n}\n\nexport const UpdateTenantRepository = createImplementation({\n    abstraction: RepositoryAbstraction,\n    implementation: UpdateTenantRepositoryImpl,\n    dependencies: [UpdateTenantGateway, TenantCache]\n});\n"],"mappings":"AAAA,SAASA,oBAAoB,QAAQ,qBAAqB;AAC1D,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,CAAC;IAC5B,IAAI,CAACN,KAAK,CAACO,KAAK,CAACJ,OAAO,CAACG,EAAE,EAAEH,OAAO,CAAC;IACrC,OAAOA,OAAO;EAClB;AACJ;AAEA,OAAO,MAAMV,sBAAsB,GAAGD,oBAAoB,CAAC;EACvDgB,WAAW,EAAEd,qBAAqB;EAClCe,cAAc,EAAEZ,0BAA0B;EAC1Ca,YAAY,EAAE,CAACf,mBAAmB,EAAEC,WAAW;AACnD,CAAC,CAAC","ignoreList":[]}

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

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

package/features/tenancy/UpdateTenant/UpdateTenantUseCase.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["EventPublisher","createImplementation","Result","UpdateTenantUseCase","UseCaseAbstraction","UpdateTenantRepository","TenantBeforeUpdateEvent","TenantAfterUpdateEvent","GetTenantByIdUseCase","UpdateTenantUseCaseImpl","constructor","getTenantById","eventPublisher","repository","execute","id","data","result","isFail","tenant","value","updateData","savedOn","Date","toISOString","publish","inputData","Object","assign","updatedTenant","update","ok","abstraction","implementation","dependencies"],"sources":["UpdateTenantUseCase.ts"],"sourcesContent":["import { EventPublisher } from \"~/features/eventPublisher/index.js\";\nimport { createImplementation } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { UpdateTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { UpdateTenantRepository } from \"./abstractions.js\";\nimport { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from \"./events.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { GetTenantByIdUseCase } from \"~/features/tenancy/GetTenantById/index.js\";\n\nclass UpdateTenantUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getTenantById: GetTenantByIdUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: UpdateTenantRepository.Interface\n    ) {}\n\n    async execute(id: string, data: Partial<Tenant>) {\n        const result = await this.getTenantById.execute(id);\n\n        if (result.isFail()) {\n            return result;\n        }\n        const tenant = result.value;\n\n        const updateData = { ...data, savedOn: new Date().toISOString() };\n\n        await this.eventPublisher.publish(\n            new TenantBeforeUpdateEvent({ tenant, inputData: data, updateData })\n        );\n\n        Object.assign(tenant, updateData);\n        const updatedTenant = await this.repository.update(tenant);\n\n        await this.eventPublisher.publish(\n            new TenantAfterUpdateEvent({ tenant: updatedTenant, inputData: data })\n        );\n\n        return Result.ok(updatedTenant);\n    }\n}\n\nexport const UpdateTenantUseCase = createImplementation({\n    abstraction: UseCaseAbstraction,\n    implementation: UpdateTenantUseCaseImpl,\n    dependencies: [GetTenantByIdUseCase, EventPublisher, UpdateTenantRepository]\n});\n"],"mappings":"AAAA,SAASA,cAAc;AACvB,SAASC,oBAAoB,QAAQ,qBAAqB;AAC1D,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,mBAAmB,IAAIC,kBAAkB;AAClD,SAASC,sBAAsB;AAC/B,SAASC,uBAAuB,EAAEC,sBAAsB;AAExD,SAASC,oBAAoB;AAE7B,MAAMC,uBAAuB,CAAyC;EAClEC,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,EAAEC,IAAqB,EAAE;IAC7C,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACN,aAAa,CAACG,OAAO,CAACC,EAAE,CAAC;IAEnD,IAAIE,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOD,MAAM;IACjB;IACA,MAAME,MAAM,GAAGF,MAAM,CAACG,KAAK;IAE3B,MAAMC,UAAU,GAAG;MAAE,GAAGL,IAAI;MAAEM,OAAO,EAAE,IAAIC,IAAI,CAAC,CAAC,CAACC,WAAW,CAAC;IAAE,CAAC;IAEjE,MAAM,IAAI,CAACZ,cAAc,CAACa,OAAO,CAC7B,IAAInB,uBAAuB,CAAC;MAAEa,MAAM;MAAEO,SAAS,EAAEV,IAAI;MAAEK;IAAW,CAAC,CACvE,CAAC;IAEDM,MAAM,CAACC,MAAM,CAACT,MAAM,EAAEE,UAAU,CAAC;IACjC,MAAMQ,aAAa,GAAG,MAAM,IAAI,CAAChB,UAAU,CAACiB,MAAM,CAACX,MAAM,CAAC;IAE1D,MAAM,IAAI,CAACP,cAAc,CAACa,OAAO,CAC7B,IAAIlB,sBAAsB,CAAC;MAAEY,MAAM,EAAEU,aAAa;MAAEH,SAAS,EAAEV;IAAK,CAAC,CACzE,CAAC;IAED,OAAOd,MAAM,CAAC6B,EAAE,CAACF,aAAa,CAAC;EACnC;AACJ;AAEA,OAAO,MAAM1B,mBAAmB,GAAGF,oBAAoB,CAAC;EACpD+B,WAAW,EAAE5B,kBAAkB;EAC/B6B,cAAc,EAAExB,uBAAuB;EACvCyB,YAAY,EAAE,CAAC1B,oBAAoB,EAAER,cAAc,EAAEK,sBAAsB;AAC/E,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,41 @@
+import { type Result } from "@webiny/feature/api";
+import type { IEventHandler, DomainEvent } from "../../../features/eventPublisher/index.js";
+import type { Tenant } from "../../../types/tenancy.js";
+import type { TenantBeforeUpdatePayload, TenantAfterUpdatePayload } from "./events.js";
+export type UpdateTenantError = {
+    type: "NOT_FOUND";
+} | {
+    type: "UNKNOWN";
+    cause: Error;
+};
+export interface IUpdateTenantUseCase {
+    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, UpdateTenantError>>;
+}
+export declare const UpdateTenantUseCase: import("@webiny/di").Abstraction<IUpdateTenantUseCase>;
+export declare namespace UpdateTenantUseCase {
+    type Interface = IUpdateTenantUseCase;
+}
+export interface IUpdateTenantRepository {
+    update(tenant: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantRepository: import("@webiny/di").Abstraction<IUpdateTenantRepository>;
+export declare namespace UpdateTenantRepository {
+    type Interface = IUpdateTenantRepository;
+}
+export interface IUpdateTenantGateway {
+    updateTenant(data: Tenant): Promise<Tenant>;
+}
+export declare const UpdateTenantGateway: import("@webiny/di").Abstraction<IUpdateTenantGateway>;
+export declare namespace UpdateTenantGateway {
+    type Interface = IUpdateTenantGateway;
+}
+export declare const TenantBeforeUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>>;
+export declare namespace TenantBeforeUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>;
+    type Event = DomainEvent<TenantBeforeUpdatePayload>;
+}
+export declare const TenantAfterUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<DomainEvent<TenantAfterUpdatePayload>>>;
+export declare namespace TenantAfterUpdateHandler {
+    type Interface = IEventHandler<DomainEvent<TenantAfterUpdatePayload>>;
+    type Event = DomainEvent<TenantAfterUpdatePayload>;
+}

package/features/tenancy/UpdateTenant/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","UpdateTenantUseCase","UpdateTenantRepository","UpdateTenantGateway","TenantBeforeUpdateHandler","TenantAfterUpdateHandler"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { IEventHandler, DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport type { TenantBeforeUpdatePayload, TenantAfterUpdatePayload } from \"./events.js\";\n\nexport type UpdateTenantError = { type: \"NOT_FOUND\" } | { type: \"UNKNOWN\"; cause: Error };\n\nexport interface IUpdateTenantUseCase {\n    execute(id: string, data: Partial<Tenant>): Promise<Result<Tenant, UpdateTenantError>>;\n}\n\nexport const UpdateTenantUseCase = createAbstraction<IUpdateTenantUseCase>(\"UpdateTenantUseCase\");\n\nexport namespace UpdateTenantUseCase {\n    export type Interface = IUpdateTenantUseCase;\n}\n\nexport interface IUpdateTenantRepository {\n    update(tenant: Tenant): Promise<Tenant>;\n}\n\nexport const UpdateTenantRepository =\n    createAbstraction<IUpdateTenantRepository>(\"UpdateTenantRepository\");\n\nexport namespace UpdateTenantRepository {\n    export type Interface = IUpdateTenantRepository;\n}\n\nexport interface IUpdateTenantGateway {\n    updateTenant(data: Tenant): Promise<Tenant>;\n}\n\nexport const UpdateTenantGateway = createAbstraction<IUpdateTenantGateway>(\"UpdateTenantGateway\");\n\nexport namespace UpdateTenantGateway {\n    export type Interface = IUpdateTenantGateway;\n}\n\nexport const TenantBeforeUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>\n>(\"TenantBeforeUpdateHandler\");\n\nexport namespace TenantBeforeUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantBeforeUpdatePayload>>;\n    export type Event = DomainEvent<TenantBeforeUpdatePayload>;\n}\n\nexport const TenantAfterUpdateHandler = createAbstraction<\n    IEventHandler<DomainEvent<TenantAfterUpdatePayload>>\n>(\"TenantAfterUpdateHandler\");\n\nexport namespace TenantAfterUpdateHandler {\n    export type Interface = IEventHandler<DomainEvent<TenantAfterUpdatePayload>>;\n    export type Event = DomainEvent<TenantAfterUpdatePayload>;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAqB,qBAAqB;AAWpE,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/UpdateTenant/events.d.ts

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

package/features/tenancy/UpdateTenant/events.js

@@ -0,0 +1,16 @@
+import { DomainEvent } from "../../eventPublisher/index.js";
+import { TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from "./abstractions.js";
+export class TenantBeforeUpdateEvent extends DomainEvent {
+  eventType = "tenant.beforeUpdate";
+  getHandlerAbstraction() {
+    return TenantBeforeUpdateHandler;
+  }
+}
+export class TenantAfterUpdateEvent extends DomainEvent {
+  eventType = "tenant.afterUpdate";
+  getHandlerAbstraction() {
+    return TenantAfterUpdateHandler;
+  }
+}
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["DomainEvent","TenantBeforeUpdateHandler","TenantAfterUpdateHandler","TenantBeforeUpdateEvent","eventType","getHandlerAbstraction","TenantAfterUpdateEvent"],"sources":["events.ts"],"sourcesContent":["import { DomainEvent } from \"~/features/eventPublisher/index.js\";\nimport type { Tenant } from \"~/types/tenancy.js\";\nimport { TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from \"./abstractions.js\";\n\nexport interface TenantBeforeUpdatePayload {\n    tenant: Tenant;\n    inputData: Record<string, any>;\n    updateData: Partial<Tenant>;\n}\n\nexport interface TenantAfterUpdatePayload {\n    tenant: Tenant;\n    inputData: Record<string, any>;\n}\n\nexport class TenantBeforeUpdateEvent extends DomainEvent<TenantBeforeUpdatePayload> {\n    eventType = \"tenant.beforeUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return TenantBeforeUpdateHandler;\n    }\n}\n\nexport class TenantAfterUpdateEvent extends DomainEvent<TenantAfterUpdatePayload> {\n    eventType = \"tenant.afterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return TenantAfterUpdateHandler;\n    }\n}\n"],"mappings":"AAAA,SAASA,WAAW;AAEpB,SAASC,yBAAyB,EAAEC,wBAAwB;AAa5D,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/UpdateTenant/feature.d.ts

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

package/features/tenancy/UpdateTenant/feature.js

@@ -0,0 +1,14 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateTenantUseCase } from "./UpdateTenantUseCase.js";
+import { UpdateTenantRepository } from "./UpdateTenantRepository.js";
+import { UpdateTenantGateway } from "./UpdateTenantGateway.js";
+export const UpdateTenantFeature = createFeature({
+  name: "UpdateTenant",
+  register(container) {
+    container.register(UpdateTenantUseCase);
+    container.register(UpdateTenantRepository).inSingletonScope();
+    container.register(UpdateTenantGateway).inSingletonScope();
+  }
+});
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","UpdateTenantUseCase","UpdateTenantRepository","UpdateTenantGateway","UpdateTenantFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport type { Container } from \"@webiny/di\";\nimport { UpdateTenantUseCase } from \"./UpdateTenantUseCase.js\";\nimport { UpdateTenantRepository } from \"./UpdateTenantRepository.js\";\nimport { UpdateTenantGateway } from \"./UpdateTenantGateway.js\";\n\nexport const UpdateTenantFeature = createFeature({\n    name: \"UpdateTenant\",\n    register(container: Container) {\n        container.register(UpdateTenantUseCase);\n        container.register(UpdateTenantRepository).inSingletonScope();\n        container.register(UpdateTenantGateway).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,mBAAmB;AAC5B,SAASC,sBAAsB;AAC/B,SAASC,mBAAmB;AAE5B,OAAO,MAAMC,mBAAmB,GAAGJ,aAAa,CAAC;EAC7CK,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAoB,EAAE;IAC3BA,SAAS,CAACD,QAAQ,CAACL,mBAAmB,CAAC;IACvCM,SAAS,CAACD,QAAQ,CAACJ,sBAAsB,CAAC,CAACM,gBAAgB,CAAC,CAAC;IAC7DD,SAAS,CAACD,QAAQ,CAACH,mBAAmB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAC9D;AACJ,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,3 @@
+export { UpdateTenantFeature } from "./feature.js";
+export { UpdateTenantUseCase, UpdateTenantRepository, UpdateTenantGateway, TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from "./abstractions.js";
+export { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from "./events.js";

package/features/tenancy/UpdateTenant/index.js

@@ -0,0 +1,5 @@
+export { UpdateTenantFeature } from "./feature.js";
+export { UpdateTenantUseCase, UpdateTenantRepository, UpdateTenantGateway, TenantBeforeUpdateHandler, TenantAfterUpdateHandler } from "./abstractions.js";
+export { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["UpdateTenantFeature","UpdateTenantUseCase","UpdateTenantRepository","UpdateTenantGateway","TenantBeforeUpdateHandler","TenantAfterUpdateHandler","TenantBeforeUpdateEvent","TenantAfterUpdateEvent"],"sources":["index.ts"],"sourcesContent":["export { UpdateTenantFeature } from \"./feature.js\";\nexport {\n    UpdateTenantUseCase,\n    UpdateTenantRepository,\n    UpdateTenantGateway,\n    TenantBeforeUpdateHandler,\n    TenantAfterUpdateHandler\n} from \"./abstractions.js\";\nexport { TenantBeforeUpdateEvent, TenantAfterUpdateEvent } 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/shared/TenantCache.d.ts

@@ -0,0 +1,13 @@
+import type { TenantCache as CacheAbstraction } from "./abstractions.js";
+import type { Tenant } from "../../../types/tenancy.js";
+export interface TenantCacheBatchLoader {
+    (ids: readonly string[]): Promise<Tenant[]>;
+}
+export declare class TenantCache implements CacheAbstraction.Interface {
+    private loader;
+    constructor(batchLoadFn: TenantCacheBatchLoader);
+    get(id: string): Promise<Tenant>;
+    getMany(ids: readonly string[]): Promise<Tenant[]>;
+    clear(id: string): void;
+    prime(id: string, tenant: Tenant | undefined): void;
+}