@webiny/tenant-manager 0.0.0-unstable.3c5210ad37

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","TenantBeforeEnableEvent","eventType","getHandlerAbstraction","TenantBeforeEnableEventHandler","TenantAfterEnableEvent","TenantAfterEnableEventHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport type { Tenant } from \"~/shared/Tenant.js\";\n\nexport interface TenantBeforeEnablePayload {\n    tenant: Tenant;\n}\n\nexport interface TenantAfterEnablePayload {\n    tenant: Tenant;\n}\n\nexport class TenantBeforeEnableEvent extends DomainEvent<TenantBeforeEnablePayload> {\n    eventType = \"tenant.beforeEnable\" as const;\n\n    getHandlerAbstraction() {\n        return TenantBeforeEnableEventHandler;\n    }\n}\n\nexport const TenantBeforeEnableEventHandler = createAbstraction<\n    IEventHandler<TenantBeforeEnableEvent>\n>(\"TenantManager/TenantBeforeEnableEventHandler\");\n\nexport namespace TenantBeforeEnableEventHandler {\n    export type Interface = IEventHandler<TenantBeforeEnableEvent>;\n    export type Event = TenantBeforeEnableEvent;\n}\n\nexport class TenantAfterEnableEvent extends DomainEvent<TenantAfterEnablePayload> {\n    eventType = \"tenant.afterEnable\" as const;\n\n    getHandlerAbstraction() {\n        return TenantAfterEnableEventHandler;\n    }\n}\n\nexport const TenantAfterEnableEventHandler = createAbstraction<\n    IEventHandler<TenantAfterEnableEvent>\n>(\"TenantManager/TenantAfterEnableEventHandler\");\n\nexport namespace TenantAfterEnableEventHandler {\n    export type Interface = IEventHandler<TenantAfterEnableEvent>;\n    export type Event = TenantAfterEnableEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,0CAA0C;AAYtE,OAAO,MAAMC,uBAAuB,SAASD,WAAW,CAA4B;EAChFE,SAAS,GAAG,qBAAqB;EAEjCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,8BAA8B;EACzC;AACJ;AAEA,OAAO,MAAMA,8BAA8B,GAAGL,iBAAiB,CAE7D,8CAA8C,CAAC;AAOjD,OAAO,MAAMM,sBAAsB,SAASL,WAAW,CAA2B;EAC9EE,SAAS,GAAG,oBAAoB;EAEhCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOG,6BAA6B;EACxC;AACJ;AAEA,OAAO,MAAMA,6BAA6B,GAAGP,iBAAiB,CAE5D,6CAA6C,CAAC","ignoreList":[]}

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

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

package/api/features/EnableTenant/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","EnableTenantUseCase","EnableTenantFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport EnableTenantUseCase from \"./EnableTenantUseCase.js\";\n\nexport const EnableTenantFeature = createFeature({\n    name: \"EnableTenant\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(EnableTenantUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,OAAOC,mBAAmB;AAE1B,OAAO,MAAMC,mBAAmB,GAAGF,aAAa,CAAC;EAC7CG,IAAI,EAAE,cAAc;EACpBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,mBAAmB,CAAC;EAC3C;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/api/features/GetCurrentTenant/GetCurrentTenantUseCase.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["GetTenantByIdUseCase","GetCurrentTenantUseCase","UseCaseAbstraction","TenantContext","IdentityContext","Result","NotAuthorizedError","constructor","tenantContext","identityContext","getTenantByIdUseCase","execute","identity","getIdentity","isAnonymous","fail","currentTenant","getTenant","result","withoutAuthorization","id","isFail","error","ok","value","createImplementation","implementation","dependencies"],"sources":["GetCurrentTenantUseCase.ts"],"sourcesContent":["import { Tenant } from \"~/shared/Tenant.js\";\nimport { GetTenantByIdUseCase } from \"../GetTenantById/abstractions.js\";\nimport { GetCurrentTenantUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/index.js\";\n\nclass GetCurrentTenantUseCase implements UseCaseAbstraction.Interface {\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private identityContext: IdentityContext.Interface,\n        private getTenantByIdUseCase: GetTenantByIdUseCase.Interface\n    ) {}\n\n    async execute(): Promise<Result<Tenant, UseCaseAbstraction.Error>> {\n        const identity = this.identityContext.getIdentity();\n        if (identity.isAnonymous()) {\n            return Result.fail(new NotAuthorizedError());\n        }\n\n        // Get the current tenant from context\n        const currentTenant = this.tenantContext.getTenant();\n\n        const result = await this.identityContext.withoutAuthorization(() => {\n            return this.getTenantByIdUseCase.execute(currentTenant.id);\n        });\n\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport default UseCaseAbstraction.createImplementation({\n    implementation: GetCurrentTenantUseCase,\n    dependencies: [TenantContext, IdentityContext, GetTenantByIdUseCase]\n});\n"],"mappings":"AACA,SAASA,oBAAoB;AAC7B,SAASC,uBAAuB,IAAIC,kBAAkB;AACtD,SAASC,aAAa,QAAQ,yCAAyC;AACvE,SAASC,eAAe,QAAQ,0CAA0C;AAC1E,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,QAAQ,oDAAoD;AAEvF,MAAML,uBAAuB,CAAyC;EAClEM,WAAWA,CACCC,aAAsC,EACtCC,eAA0C,EAC1CC,oBAAoD,EAC9D;IAAA,KAHUF,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,oBAAoD,GAApDA,oBAAoD;EAC7D;EAEH,MAAMC,OAAOA,CAAA,EAAsD;IAC/D,MAAMC,QAAQ,GAAG,IAAI,CAACH,eAAe,CAACI,WAAW,CAAC,CAAC;IACnD,IAAID,QAAQ,CAACE,WAAW,CAAC,CAAC,EAAE;MACxB,OAAOT,MAAM,CAACU,IAAI,CAAC,IAAIT,kBAAkB,CAAC,CAAC,CAAC;IAChD;;IAEA;IACA,MAAMU,aAAa,GAAG,IAAI,CAACR,aAAa,CAACS,SAAS,CAAC,CAAC;IAEpD,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACT,eAAe,CAACU,oBAAoB,CAAC,MAAM;MACjE,OAAO,IAAI,CAACT,oBAAoB,CAACC,OAAO,CAACK,aAAa,CAACI,EAAE,CAAC;IAC9D,CAAC,CAAC;IAEF,IAAIF,MAAM,CAACG,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOhB,MAAM,CAACU,IAAI,CAACG,MAAM,CAACI,KAAK,CAAC;IACpC;IAEA,OAAOjB,MAAM,CAACkB,EAAE,CAACL,MAAM,CAACM,KAAK,CAAC;EAClC;AACJ;AAEA,eAAetB,kBAAkB,CAACuB,oBAAoB,CAAC;EACnDC,cAAc,EAAEzB,uBAAuB;EACvC0B,YAAY,EAAE,CAACxB,aAAa,EAAEC,eAAe,EAAEJ,oBAAoB;AACvE,CAAC,CAAC","ignoreList":[]}

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

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

package/api/features/GetCurrentTenant/abstractions.js

@@ -0,0 +1,10 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetCurrentTenant Use Case
+ * Gets the tenant associated with the current tenant context
+ */
+
+export const GetCurrentTenantUseCase = createAbstraction("TenantManager/GetCurrentTenantUseCase");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetCurrentTenantUseCase"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport type { Tenant } from \"~/shared/Tenant.js\";\nimport type {\n    TenantModelNotFoundError,\n    TenantNotFoundError,\n    TenantPersistenceError\n} from \"../../domain/errors.js\";\n\n/**\n * GetCurrentTenant Use Case\n * Gets the tenant associated with the current tenant context\n */\nexport interface IGetCurrentTenantUseCase {\n    execute(): Promise<Result<Tenant, UseCaseError>>;\n}\n\nexport interface IGetCurrentTenantUseCaseErrors {\n    notFound: TenantNotFoundError;\n    notAuthorized: NotAuthorizedError;\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n}\n\ntype UseCaseError = IGetCurrentTenantUseCaseErrors[keyof IGetCurrentTenantUseCaseErrors];\n\nexport const GetCurrentTenantUseCase = createAbstraction<IGetCurrentTenantUseCase>(\n    \"TenantManager/GetCurrentTenantUseCase\"\n);\n\nexport namespace GetCurrentTenantUseCase {\n    export type Interface = IGetCurrentTenantUseCase;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAUvD;AACA;AACA;AACA;;AAcA,OAAO,MAAMC,uBAAuB,GAAGD,iBAAiB,CACpD,uCACJ,CAAC","ignoreList":[]}

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

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

package/api/features/GetCurrentTenant/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetCurrentTenantUseCase","GetCurrentTenantFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport GetCurrentTenantUseCase from \"./GetCurrentTenantUseCase.js\";\n\nexport const GetCurrentTenantFeature = createFeature({\n    name: \"GetCurrentTenant\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(GetCurrentTenantUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,OAAOC,uBAAuB;AAE9B,OAAO,MAAMC,uBAAuB,GAAGF,aAAa,CAAC;EACjDG,IAAI,EAAE,kBAAkB;EACxBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACH,uBAAuB,CAAC;EAC/C;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/api/features/GetTenantById/GetTenantByIdRepository.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","Tenant","TENANT_MODEL_ID","TenantModelNotFoundError","TenantNotFoundError","TenantPersistenceError","GetTenantByIdRepository","RepositoryAbstraction","TenantContext","GetModelUseCase","GetEntryByIdUseCase","EntryId","constructor","tenantContext","getModelUseCase","getEntryUseCase","execute","id","entryId","from","modelResult","isFail","fail","entryResult","withRootTenant","value","toString","tenantEntry","tenantDto","values","ok","error","createImplementation","implementation","dependencies"],"sources":["GetTenantByIdRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Tenant, TenantDto, TenantValues } from \"~/shared/Tenant.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\nimport {\n    TenantModelNotFoundError,\n    TenantNotFoundError,\n    TenantPersistenceError\n} from \"../../domain/errors.js\";\nimport { GetTenantByIdRepository as RepositoryAbstraction } from \"./abstractions.js\";\nimport { TenantContext } from \"@webiny/api-core/exports/api/tenancy.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/abstractions.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/abstractions.js\";\nimport { EntryId } from \"@webiny/api-headless-cms/domain/contentEntry/EntryId.js\";\n\nclass GetTenantByIdRepository implements RepositoryAbstraction.Interface {\n    constructor(\n        private tenantContext: TenantContext.Interface,\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryUseCase: GetEntryByIdUseCase.Interface\n    ) {}\n\n    async execute(id: string): Promise<Result<Tenant, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = EntryId.from(id);\n\n            // Get the tenant model\n            const modelResult = await this.getModelUseCase.execute(TENANT_MODEL_ID);\n            if (modelResult.isFail()) {\n                return Result.fail(new TenantModelNotFoundError());\n            }\n\n            // Get the tenant entry\n            const entryResult = await this.tenantContext.withRootTenant(() => {\n                return this.getEntryUseCase.execute<TenantValues>(\n                    modelResult.value,\n                    entryId.toString()\n                );\n            });\n\n            if (entryResult.isFail()) {\n                return Result.fail(new TenantNotFoundError(id));\n            }\n\n            const tenantEntry = entryResult.value;\n\n            const tenantDto: TenantDto = {\n                id: tenantEntry.entryId,\n                values: tenantEntry.values\n            };\n\n            return Result.ok(Tenant.from(tenantDto));\n        } catch (error) {\n            return Result.fail(new TenantPersistenceError(error as Error));\n        }\n    }\n}\n\nexport default RepositoryAbstraction.createImplementation({\n    implementation: GetTenantByIdRepository,\n    dependencies: [TenantContext, GetModelUseCase, GetEntryByIdUseCase]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,MAAM;AACf,SAASC,eAAe;AACxB,SACIC,wBAAwB,EACxBC,mBAAmB,EACnBC,sBAAsB;AAE1B,SAASC,uBAAuB,IAAIC,qBAAqB;AACzD,SAASC,aAAa,QAAQ,yCAAyC;AACvE,SAASC,eAAe,QAAQ,yEAAyE;AACzG,SAASC,mBAAmB,QAAQ,6EAA6E;AACjH,SAASC,OAAO,QAAQ,yDAAyD;AAEjF,MAAML,uBAAuB,CAA4C;EACrEM,WAAWA,CACCC,aAAsC,EACtCC,eAA0C,EAC1CC,eAA8C,EACxD;IAAA,KAHUF,aAAsC,GAAtCA,aAAsC;IAAA,KACtCC,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,eAA8C,GAA9CA,eAA8C;EACvD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAwD;IAC5E,IAAI;MACA,MAAMC,OAAO,GAAGP,OAAO,CAACQ,IAAI,CAACF,EAAE,CAAC;;MAEhC;MACA,MAAMG,WAAW,GAAG,MAAM,IAAI,CAACN,eAAe,CAACE,OAAO,CAACd,eAAe,CAAC;MACvE,IAAIkB,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;QACtB,OAAOrB,MAAM,CAACsB,IAAI,CAAC,IAAInB,wBAAwB,CAAC,CAAC,CAAC;MACtD;;MAEA;MACA,MAAMoB,WAAW,GAAG,MAAM,IAAI,CAACV,aAAa,CAACW,cAAc,CAAC,MAAM;QAC9D,OAAO,IAAI,CAACT,eAAe,CAACC,OAAO,CAC/BI,WAAW,CAACK,KAAK,EACjBP,OAAO,CAACQ,QAAQ,CAAC,CACrB,CAAC;MACL,CAAC,CAAC;MAEF,IAAIH,WAAW,CAACF,MAAM,CAAC,CAAC,EAAE;QACtB,OAAOrB,MAAM,CAACsB,IAAI,CAAC,IAAIlB,mBAAmB,CAACa,EAAE,CAAC,CAAC;MACnD;MAEA,MAAMU,WAAW,GAAGJ,WAAW,CAACE,KAAK;MAErC,MAAMG,SAAoB,GAAG;QACzBX,EAAE,EAAEU,WAAW,CAACT,OAAO;QACvBW,MAAM,EAAEF,WAAW,CAACE;MACxB,CAAC;MAED,OAAO7B,MAAM,CAAC8B,EAAE,CAAC7B,MAAM,CAACkB,IAAI,CAACS,SAAS,CAAC,CAAC;IAC5C,CAAC,CAAC,OAAOG,KAAK,EAAE;MACZ,OAAO/B,MAAM,CAACsB,IAAI,CAAC,IAAIjB,sBAAsB,CAAC0B,KAAc,CAAC,CAAC;IAClE;EACJ;AACJ;AAEA,eAAexB,qBAAqB,CAACyB,oBAAoB,CAAC;EACtDC,cAAc,EAAE3B,uBAAuB;EACvC4B,YAAY,EAAE,CAAC1B,aAAa,EAAEC,eAAe,EAAEC,mBAAmB;AACtE,CAAC,CAAC","ignoreList":[]}

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

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

package/api/features/GetTenantById/GetTenantByIdUseCase.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["Tenant","rootTenantDto","GetTenantByIdUseCase","UseCaseAbstraction","GetTenantByIdRepository","Result","constructor","repository","execute","id","ok","from","result","isFail","fail","error","value","createImplementation","implementation","dependencies"],"sources":["GetTenantByIdUseCase.ts"],"sourcesContent":["import { Tenant, rootTenantDto } from \"~/shared/Tenant.js\";\nimport {\n    GetTenantByIdUseCase as UseCaseAbstraction,\n    GetTenantByIdRepository\n} from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\n\nclass GetTenantByIdUseCase implements UseCaseAbstraction.Interface {\n    constructor(private repository: GetTenantByIdRepository.Interface) {}\n\n    async execute(id: string): Promise<Result<Tenant, UseCaseAbstraction.Error>> {\n        // Handle special root tenant case\n        if (id === \"root\") {\n            return Result.ok(Tenant.from(rootTenantDto));\n        }\n\n        // Delegate to repository\n        const result = await this.repository.execute(id);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport default UseCaseAbstraction.createImplementation({\n    implementation: GetTenantByIdUseCase,\n    dependencies: [GetTenantByIdRepository]\n});\n"],"mappings":"AAAA,SAASA,MAAM,EAAEC,aAAa;AAC9B,SACIC,oBAAoB,IAAIC,kBAAkB,EAC1CC,uBAAuB;AAE3B,SAASC,MAAM,QAAQ,qBAAqB;AAE5C,MAAMH,oBAAoB,CAAyC;EAC/DI,WAAWA,CAASC,UAA6C,EAAE;IAAA,KAA/CA,UAA6C,GAA7CA,UAA6C;EAAG;EAEpE,MAAMC,OAAOA,CAACC,EAAU,EAAqD;IACzE;IACA,IAAIA,EAAE,KAAK,MAAM,EAAE;MACf,OAAOJ,MAAM,CAACK,EAAE,CAACV,MAAM,CAACW,IAAI,CAACV,aAAa,CAAC,CAAC;IAChD;;IAEA;IACA,MAAMW,MAAM,GAAG,MAAM,IAAI,CAACL,UAAU,CAACC,OAAO,CAACC,EAAE,CAAC;IAChD,IAAIG,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOR,MAAM,CAACS,IAAI,CAACF,MAAM,CAACG,KAAK,CAAC;IACpC;IAEA,OAAOV,MAAM,CAACK,EAAE,CAACE,MAAM,CAACI,KAAK,CAAC;EAClC;AACJ;AAEA,eAAeb,kBAAkB,CAACc,oBAAoB,CAAC;EACnDC,cAAc,EAAEhB,oBAAoB;EACpCiB,YAAY,EAAE,CAACf,uBAAuB;AAC1C,CAAC,CAAC","ignoreList":[]}

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

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

package/api/features/GetTenantById/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetTenantById Use Case
+ */
+
+export const GetTenantByIdUseCase = createAbstraction("TenantManager/GetTenantByIdUseCase");
+
+/**
+ * GetTenantByIdRepository - Retrieves a tenant from storage.
+ */
+
+export const GetTenantByIdRepository = createAbstraction("TenantManager/GetTenantByIdRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetTenantByIdUseCase","GetTenantByIdRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { Tenant } from \"../../../shared/Tenant.js\";\nimport {\n    TenantModelNotFoundError,\n    type TenantNotFoundError,\n    type TenantPersistenceError\n} from \"../../domain/errors.js\";\n\n/**\n * GetTenantById Use Case\n */\nexport interface IGetTenantByIdUseCase {\n    execute(id: string): Promise<Result<Tenant, UseCaseError>>;\n}\n\nexport interface IGetTenantByIdUseCaseErrors {\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n}\n\ntype UseCaseError = IGetTenantByIdUseCaseErrors[keyof IGetTenantByIdUseCaseErrors];\n\nexport const GetTenantByIdUseCase = createAbstraction<IGetTenantByIdUseCase>(\n    \"TenantManager/GetTenantByIdUseCase\"\n);\n\nexport namespace GetTenantByIdUseCase {\n    export type Interface = IGetTenantByIdUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * GetTenantByIdRepository - Retrieves a tenant from storage.\n */\nexport interface IGetTenantByIdRepository {\n    execute(id: string): Promise<Result<Tenant, RepositoryError>>;\n}\n\nexport interface IGetTenantByIdRepositoryErrors {\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n}\n\ntype RepositoryError = IGetTenantByIdRepositoryErrors[keyof IGetTenantByIdRepositoryErrors];\n\nexport const GetTenantByIdRepository = createAbstraction<IGetTenantByIdRepository>(\n    \"TenantManager/GetTenantByIdRepository\"\n);\n\nexport namespace GetTenantByIdRepository {\n    export type Interface = IGetTenantByIdRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AASvD;AACA;AACA;;AAaA,OAAO,MAAMC,oBAAoB,GAAGD,iBAAiB,CACjD,oCACJ,CAAC;;AAOD;AACA;AACA;;AAaA,OAAO,MAAME,uBAAuB,GAAGF,iBAAiB,CACpD,uCACJ,CAAC","ignoreList":[]}

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

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

package/api/features/GetTenantById/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetTenantByIdUseCase","GetTenantByIdRepository","GetTenantByIdFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport GetTenantByIdUseCase from \"./GetTenantByIdUseCase.js\";\nimport GetTenantByIdRepository from \"./GetTenantByIdRepository.js\";\n\nexport const GetTenantByIdFeature = createFeature({\n    name: \"GetTenantById\",\n    register(container) {\n        // Register use case (transient scope)\n        container.register(GetTenantByIdUseCase);\n\n        // Register repository (singleton scope)\n        container.register(GetTenantByIdRepository).inSingletonScope();\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,OAAOC,oBAAoB;AAC3B,OAAOC,uBAAuB;AAE9B,OAAO,MAAMC,oBAAoB,GAAGH,aAAa,CAAC;EAC9CI,IAAI,EAAE,eAAe;EACrBC,QAAQA,CAACC,SAAS,EAAE;IAChB;IACAA,SAAS,CAACD,QAAQ,CAACJ,oBAAoB,CAAC;;IAExC;IACAK,SAAS,CAACD,QAAQ,CAACH,uBAAuB,CAAC,CAACK,gBAAgB,CAAC,CAAC;EAClE;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/api/features/UpdateTenant/UpdateTenantRepository.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["Tenant","TENANT_MODEL_ID","TenantNotFoundError","TenantPersistenceError","UpdateTenantRepository","RepositoryAbstraction","Result","EntryId","GetEntryUseCase","UpdateEntryUseCase","GetModelUseCase","constructor","getModelUseCase","getEntryUseCase","updateEntryUseCase","execute","id","input","entryId","from","modelResult","isFail","fail","Error","getEntryResult","value","where","latest","updateResult","toString","values","error","updatedEntry","tenantDto","ok","createImplementation","implementation","dependencies"],"sources":["UpdateTenantRepository.ts"],"sourcesContent":["import { Tenant, TenantDto, TenantValues } from \"~/shared/Tenant.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\nimport { TenantNotFoundError, TenantPersistenceError } from \"../../domain/errors.js\";\nimport {\n    UpdateTenantRepository as RepositoryAbstraction,\n    UpdateTenantInput\n} from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { GetEntryUseCase } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/exports/api/cms/model\";\n\nclass UpdateTenantRepository implements RepositoryAbstraction.Interface {\n    constructor(\n        private getModelUseCase: GetModelUseCase.Interface,\n        private getEntryUseCase: GetEntryUseCase.Interface,\n        private updateEntryUseCase: UpdateEntryUseCase.Interface\n    ) {}\n\n    async execute(\n        id: string,\n        input: UpdateTenantInput\n    ): Promise<Result<Tenant, RepositoryAbstraction.Error>> {\n        try {\n            const entryId = EntryId.from(id);\n\n            // Get the tenant model\n            const modelResult = await this.getModelUseCase.execute(TENANT_MODEL_ID);\n            if (modelResult.isFail()) {\n                return Result.fail(\n                    new TenantPersistenceError(\n                        new Error(`Model \"${TENANT_MODEL_ID}\" was not found!`)\n                    )\n                );\n            }\n\n            // Get the current tenant entry to verify it exists\n            const getEntryResult = await this.getEntryUseCase.execute<TenantValues>(\n                modelResult.value,\n                {\n                    where: { entryId: entryId.id, latest: true }\n                }\n            );\n\n            if (getEntryResult.isFail()) {\n                return Result.fail(new TenantNotFoundError(id));\n            }\n\n            const updateResult = await this.updateEntryUseCase.execute(\n                modelResult.value,\n                entryId.toString(),\n                {\n                    values: input\n                }\n            );\n\n            if (updateResult.isFail()) {\n                return Result.fail(new TenantPersistenceError(updateResult.error));\n            }\n\n            const updatedEntry = updateResult.value;\n\n            const tenantDto: TenantDto = {\n                id: updatedEntry.entryId,\n                values: updatedEntry.values as TenantValues\n            };\n\n            return Result.ok(Tenant.from(tenantDto));\n        } catch (error) {\n            return Result.fail(new TenantPersistenceError(error));\n        }\n    }\n}\n\nexport default RepositoryAbstraction.createImplementation({\n    implementation: UpdateTenantRepository,\n    dependencies: [GetModelUseCase, GetEntryUseCase, UpdateEntryUseCase]\n});\n"],"mappings":"AAAA,SAASA,MAAM;AACf,SAASC,eAAe;AACxB,SAASC,mBAAmB,EAAEC,sBAAsB;AACpD,SACIC,sBAAsB,IAAIC,qBAAqB;AAGnD,SAASC,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,OAAO,QAAQ,mDAAmD;AAC3E,SAASC,eAAe,QAAQ,mDAAmD;AACnF,SAASC,kBAAkB,QAAQ,mDAAmD;AACtF,SAASC,eAAe,QAAQ,gDAAgD;AAEhF,MAAMN,sBAAsB,CAA4C;EACpEO,WAAWA,CACCC,eAA0C,EAC1CC,eAA0C,EAC1CC,kBAAgD,EAC1D;IAAA,KAHUF,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,kBAAgD,GAAhDA,kBAAgD;EACzD;EAEH,MAAMC,OAAOA,CACTC,EAAU,EACVC,KAAwB,EAC4B;IACpD,IAAI;MACA,MAAMC,OAAO,GAAGX,OAAO,CAACY,IAAI,CAACH,EAAE,CAAC;;MAEhC;MACA,MAAMI,WAAW,GAAG,MAAM,IAAI,CAACR,eAAe,CAACG,OAAO,CAACd,eAAe,CAAC;MACvE,IAAImB,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;QACtB,OAAOf,MAAM,CAACgB,IAAI,CACd,IAAInB,sBAAsB,CACtB,IAAIoB,KAAK,CAAC,UAAUtB,eAAe,kBAAkB,CACzD,CACJ,CAAC;MACL;;MAEA;MACA,MAAMuB,cAAc,GAAG,MAAM,IAAI,CAACX,eAAe,CAACE,OAAO,CACrDK,WAAW,CAACK,KAAK,EACjB;QACIC,KAAK,EAAE;UAAER,OAAO,EAAEA,OAAO,CAACF,EAAE;UAAEW,MAAM,EAAE;QAAK;MAC/C,CACJ,CAAC;MAED,IAAIH,cAAc,CAACH,MAAM,CAAC,CAAC,EAAE;QACzB,OAAOf,MAAM,CAACgB,IAAI,CAAC,IAAIpB,mBAAmB,CAACc,EAAE,CAAC,CAAC;MACnD;MAEA,MAAMY,YAAY,GAAG,MAAM,IAAI,CAACd,kBAAkB,CAACC,OAAO,CACtDK,WAAW,CAACK,KAAK,EACjBP,OAAO,CAACW,QAAQ,CAAC,CAAC,EAClB;QACIC,MAAM,EAAEb;MACZ,CACJ,CAAC;MAED,IAAIW,YAAY,CAACP,MAAM,CAAC,CAAC,EAAE;QACvB,OAAOf,MAAM,CAACgB,IAAI,CAAC,IAAInB,sBAAsB,CAACyB,YAAY,CAACG,KAAK,CAAC,CAAC;MACtE;MAEA,MAAMC,YAAY,GAAGJ,YAAY,CAACH,KAAK;MAEvC,MAAMQ,SAAoB,GAAG;QACzBjB,EAAE,EAAEgB,YAAY,CAACd,OAAO;QACxBY,MAAM,EAAEE,YAAY,CAACF;MACzB,CAAC;MAED,OAAOxB,MAAM,CAAC4B,EAAE,CAAClC,MAAM,CAACmB,IAAI,CAACc,SAAS,CAAC,CAAC;IAC5C,CAAC,CAAC,OAAOF,KAAK,EAAE;MACZ,OAAOzB,MAAM,CAACgB,IAAI,CAAC,IAAInB,sBAAsB,CAAC4B,KAAK,CAAC,CAAC;IACzD;EACJ;AACJ;AAEA,eAAe1B,qBAAqB,CAAC8B,oBAAoB,CAAC;EACtDC,cAAc,EAAEhC,sBAAsB;EACtCiC,YAAY,EAAE,CAAC3B,eAAe,EAAEF,eAAe,EAAEC,kBAAkB;AACvE,CAAC,CAAC","ignoreList":[]}

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

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

package/api/features/UpdateTenant/UpdateTenantUseCase.js

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateTenantUseCase as UseCaseAbstraction, UpdateTenantRepository } from "./abstractions.js";
+class UpdateTenantUseCase {
+  constructor(repository) {
+    this.repository = repository;
+  }
+  async execute(id, input) {
+    // Delegate to repository
+    const result = await this.repository.execute(id, input);
+    if (result.isFail()) {
+      return Result.fail(result.error);
+    }
+    return Result.ok(result.value);
+  }
+}
+export default UseCaseAbstraction.createImplementation({
+  implementation: UpdateTenantUseCase,
+  dependencies: [UpdateTenantRepository]
+});
+
+//# sourceMappingURL=UpdateTenantUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","UpdateTenantUseCase","UseCaseAbstraction","UpdateTenantRepository","constructor","repository","execute","id","input","result","isFail","fail","error","ok","value","createImplementation","implementation","dependencies"],"sources":["UpdateTenantUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Tenant } from \"~/shared/Tenant.js\";\nimport {\n    UpdateTenantUseCase as UseCaseAbstraction,\n    UpdateTenantRepository,\n    UpdateTenantInput\n} from \"./abstractions.js\";\n\nclass UpdateTenantUseCase implements UseCaseAbstraction.Interface {\n    constructor(private repository: UpdateTenantRepository.Interface) {}\n\n    async execute(\n        id: string,\n        input: UpdateTenantInput\n    ): Promise<Result<Tenant, UseCaseAbstraction.Error>> {\n        // Delegate to repository\n        const result = await this.repository.execute(id, input);\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        return Result.ok(result.value);\n    }\n}\n\nexport default UseCaseAbstraction.createImplementation({\n    implementation: UpdateTenantUseCase,\n    dependencies: [UpdateTenantRepository]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAE5C,SACIC,mBAAmB,IAAIC,kBAAkB,EACzCC,sBAAsB;AAI1B,MAAMF,mBAAmB,CAAyC;EAC9DG,WAAWA,CAASC,UAA4C,EAAE;IAAA,KAA9CA,UAA4C,GAA5CA,UAA4C;EAAG;EAEnE,MAAMC,OAAOA,CACTC,EAAU,EACVC,KAAwB,EACyB;IACjD;IACA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACJ,UAAU,CAACC,OAAO,CAACC,EAAE,EAAEC,KAAK,CAAC;IACvD,IAAIC,MAAM,CAACC,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOV,MAAM,CAACW,IAAI,CAACF,MAAM,CAACG,KAAK,CAAC;IACpC;IAEA,OAAOZ,MAAM,CAACa,EAAE,CAACJ,MAAM,CAACK,KAAK,CAAC;EAClC;AACJ;AAEA,eAAeZ,kBAAkB,CAACa,oBAAoB,CAAC;EACnDC,cAAc,EAAEf,mBAAmB;EACnCgB,YAAY,EAAE,CAACd,sBAAsB;AACzC,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,39 @@
+import { Result } from "@webiny/feature/api";
+import type { Tenant, TenantValues } from "../../../shared/Tenant.js";
+import { TenantModelNotFoundError, type TenantNotFoundError, type TenantPersistenceError } from "../../domain/errors.js";
+/**
+ * UpdateTenant Use Case
+ */
+export interface UpdateTenantInput extends Partial<TenantValues> {
+}
+export interface IUpdateTenantUseCase {
+    execute(id: string, input: UpdateTenantInput): Promise<Result<Tenant, UseCaseError>>;
+}
+export interface IUpdateTenantUseCaseErrors {
+    notFound: TenantNotFoundError;
+    persistence: TenantPersistenceError;
+    modelNotFoundError: TenantModelNotFoundError;
+}
+type UseCaseError = IUpdateTenantUseCaseErrors[keyof IUpdateTenantUseCaseErrors];
+export declare const UpdateTenantUseCase: import("@webiny/di").Abstraction<IUpdateTenantUseCase>;
+export declare namespace UpdateTenantUseCase {
+    type Interface = IUpdateTenantUseCase;
+    type Error = UseCaseError;
+}
+/**
+ * UpdateTenantRepository - Updates a tenant in storage.
+ */
+export interface IUpdateTenantRepository {
+    execute(id: string, input: UpdateTenantInput): Promise<Result<Tenant, RepositoryError>>;
+}
+export interface IUpdateTenantRepositoryErrors {
+    notFound: TenantNotFoundError;
+    persistence: TenantPersistenceError;
+}
+type RepositoryError = IUpdateTenantRepositoryErrors[keyof IUpdateTenantRepositoryErrors];
+export declare const UpdateTenantRepository: import("@webiny/di").Abstraction<IUpdateTenantRepository>;
+export declare namespace UpdateTenantRepository {
+    type Interface = IUpdateTenantRepository;
+    type Error = RepositoryError;
+}
+export {};

package/api/features/UpdateTenant/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * UpdateTenant Use Case
+ */
+
+export const UpdateTenantUseCase = createAbstraction("TenantManager/UpdateTenantUseCase");
+
+/**
+ * UpdateTenantRepository - Updates a tenant in storage.
+ */
+
+export const UpdateTenantRepository = createAbstraction("TenantManager/UpdateTenantRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","UpdateTenantUseCase","UpdateTenantRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { Result } from \"@webiny/feature/api\";\nimport type { Tenant, TenantValues } from \"~/shared/Tenant.js\";\nimport {\n    TenantModelNotFoundError,\n    type TenantNotFoundError,\n    type TenantPersistenceError\n} from \"../../domain/errors.js\";\n\n/**\n * UpdateTenant Use Case\n */\nexport interface UpdateTenantInput extends Partial<TenantValues> {}\n\nexport interface IUpdateTenantUseCase {\n    execute(id: string, input: UpdateTenantInput): Promise<Result<Tenant, UseCaseError>>;\n}\n\nexport interface IUpdateTenantUseCaseErrors {\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n    modelNotFoundError: TenantModelNotFoundError;\n}\n\ntype UseCaseError = IUpdateTenantUseCaseErrors[keyof IUpdateTenantUseCaseErrors];\n\nexport const UpdateTenantUseCase = createAbstraction<IUpdateTenantUseCase>(\n    \"TenantManager/UpdateTenantUseCase\"\n);\n\nexport namespace UpdateTenantUseCase {\n    export type Interface = IUpdateTenantUseCase;\n    export type Error = UseCaseError;\n}\n\n/**\n * UpdateTenantRepository - Updates a tenant in storage.\n */\nexport interface IUpdateTenantRepository {\n    execute(id: string, input: UpdateTenantInput): Promise<Result<Tenant, RepositoryError>>;\n}\n\nexport interface IUpdateTenantRepositoryErrors {\n    notFound: TenantNotFoundError;\n    persistence: TenantPersistenceError;\n}\n\ntype RepositoryError = IUpdateTenantRepositoryErrors[keyof IUpdateTenantRepositoryErrors];\n\nexport const UpdateTenantRepository = createAbstraction<IUpdateTenantRepository>(\n    \"TenantManager/UpdateTenantRepository\"\n);\n\nexport namespace UpdateTenantRepository {\n    export type Interface = IUpdateTenantRepository;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AASvD;AACA;AACA;;AAeA,OAAO,MAAMC,mBAAmB,GAAGD,iBAAiB,CAChD,mCACJ,CAAC;;AAOD;AACA;AACA;;AAYA,OAAO,MAAME,sBAAsB,GAAGF,iBAAiB,CACnD,sCACJ,CAAC","ignoreList":[]}

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

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

package/api/features/UpdateTenant/feature.js

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

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

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

package/api/graphql/CreateTenantSchema.d.ts

@@ -0,0 +1,14 @@
+import { GraphQLSchemaFactory } from "@webiny/handler-graphql/graphql/abstractions.js";
+import { PluginsContainer } from "@webiny/api-headless-cms/legacy/abstractions.js";
+import { ListModelsUseCase } from "@webiny/api-headless-cms/exports/api/cms/model.js";
+declare class CreateTenantSchema implements GraphQLSchemaFactory.Interface {
+    private pluginsContainer;
+    private listModelsUseCase;
+    constructor(pluginsContainer: PluginsContainer.Interface, listModelsUseCase: ListModelsUseCase.Interface);
+    execute(builder: GraphQLSchemaFactory.SchemaBuilder): Promise<GraphQLSchemaFactory.SchemaBuilder>;
+    private getExtensionsInput;
+}
+declare const _default: typeof CreateTenantSchema & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/handler-graphql/graphql/abstractions.public.js").IGraphQLSchemaFactory>;
+};
+export default _default;