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

package/admin/TenantSelector.js

@@ -0,0 +1,35 @@
+import react from "react";
+import { TenantSelector as app_admin_TenantSelector, useAuthentication } from "@webiny/app-admin";
+import { CopyButton, Icon, Tooltip, useToast } from "@webiny/admin-ui";
+import { ReactComponent } from "@webiny/icons/business.svg";
+const TenantSelector_TenantSelector = app_admin_TenantSelector.createDecorator(()=>function() {
+        const { identity } = useAuthentication();
+        const currentTenant = identity.currentTenant;
+        const toast = useToast();
+        const confirmClipboard = ()=>{
+            toast.showSuccessToast({
+                title: "Tenant ID copied to clipboard!"
+            });
+        };
+        return /*#__PURE__*/ react.createElement(Tooltip, {
+            content: /*#__PURE__*/ react.createElement("div", {
+                className: "flex items-center gap-x-xs"
+            }, "ID: ", currentTenant.id, /*#__PURE__*/ react.createElement(CopyButton, {
+                size: "sm",
+                value: currentTenant.id,
+                onCopy: confirmClipboard,
+                variant: "ghost-negative"
+            })),
+            side: "bottom",
+            trigger: /*#__PURE__*/ react.createElement("div", {
+                className: "flex items-center gap-x-xs cursor-pointer"
+            }, /*#__PURE__*/ react.createElement(Icon, {
+                label: "Root tenant",
+                icon: /*#__PURE__*/ react.createElement(ReactComponent, null),
+                className: "fill-neutral-xstrong"
+            }), currentTenant.name)
+        });
+    });
+export { TenantSelector_TenantSelector as TenantSelector };
+
+//# sourceMappingURL=TenantSelector.js.map

package/admin/TenantSelector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/TenantSelector.js","sources":["../../src/admin/TenantSelector.tsx"],"sourcesContent":["import React from \"react\";\nimport { TenantSelector as BaseTenantSelector } from \"@webiny/app-admin\";\nimport { CopyButton, Icon, Tooltip, useToast } from \"@webiny/admin-ui\";\nimport { useAuthentication } from \"@webiny/app-admin\";\nimport { ReactComponent as TenantIcon } from \"@webiny/icons/business.svg\";\n\nexport const TenantSelector = BaseTenantSelector.createDecorator(() => {\n    return function TenantSelector() {\n        const { identity } = useAuthentication();\n        const currentTenant = identity.currentTenant;\n        const toast = useToast();\n\n        const confirmClipboard = () => {\n            toast.showSuccessToast({\n                title: \"Tenant ID copied to clipboard!\"\n            });\n        };\n\n        return (\n            <Tooltip\n                content={\n                    <div className={\"flex items-center gap-x-xs\"}>\n                        ID: {currentTenant.id}\n                        <CopyButton\n                            size=\"sm\"\n                            value={currentTenant.id}\n                            onCopy={confirmClipboard}\n                            variant={\"ghost-negative\"}\n                        />\n                    </div>\n                }\n                side={\"bottom\"}\n                trigger={\n                    <div className={\"flex items-center gap-x-xs cursor-pointer\"}>\n                        <Icon\n                            label=\"Root tenant\"\n                            icon={<TenantIcon />}\n                            className={\"fill-neutral-xstrong\"}\n                        />\n                        {currentTenant.name}\n                    </div>\n                }\n            />\n        );\n    };\n});\n"],"names":["TenantSelector","BaseTenantSelector","identity","useAuthentication","currentTenant","toast","useToast","confirmClipboard","Tooltip","CopyButton","Icon","TenantIcon"],"mappings":";;;;AAMO,MAAMA,gCAAiBC,yBAAAA,eAAkC,CAAC,IACtD;QACH,MAAM,EAAEC,QAAQ,EAAE,GAAGC;QACrB,MAAMC,gBAAgBF,SAAS,aAAa;QAC5C,MAAMG,QAAQC;QAEd,MAAMC,mBAAmB;YACrBF,MAAM,gBAAgB,CAAC;gBACnB,OAAO;YACX;QACJ;QAEA,OAAO,WAAP,GACI,oBAACG,SAAOA;YACJ,uBACI,oBAAC;gBAAI,WAAW;eAA8B,QACrCJ,cAAc,EAAE,gBACrB,oBAACK,YAAUA;gBACP,MAAK;gBACL,OAAOL,cAAc,EAAE;gBACvB,QAAQG;gBACR,SAAS;;YAIrB,MAAM;YACN,uBACI,oBAAC;gBAAI,WAAW;6BACZ,oBAACG,MAAIA;gBACD,OAAM;gBACN,oBAAM,oBAACC,gBAAUA;gBACjB,WAAW;gBAEdP,cAAc,IAAI;;IAKvC"}

package/admin/domain/permissionsSchema.d.ts

@@ -0,0 +1,4 @@
+export declare const TM_PERMISSIONS_SCHEMA: {
+    readonly prefix: "tm";
+    readonly fullAccess: true;
+};

package/admin/domain/permissionsSchema.js

@@ -0,0 +1,8 @@
+import { createPermissionSchema } from "@webiny/app-admin";
+const TM_PERMISSIONS_SCHEMA = createPermissionSchema({
+    prefix: "tm",
+    fullAccess: true
+});
+export { TM_PERMISSIONS_SCHEMA };
+
+//# sourceMappingURL=permissionsSchema.js.map

package/admin/domain/permissionsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/domain/permissionsSchema.js","sources":["../../../src/admin/domain/permissionsSchema.ts"],"sourcesContent":["import { createPermissionSchema } from \"@webiny/app-admin\";\n\nexport const TM_PERMISSIONS_SCHEMA = createPermissionSchema({\n    prefix: \"tm\",\n    fullAccess: true\n});\n"],"names":["TM_PERMISSIONS_SCHEMA","createPermissionSchema"],"mappings":";AAEO,MAAMA,wBAAwBC,uBAAuB;IACxD,QAAQ;IACR,YAAY;AAChB"}

package/admin/features/permissions/abstractions.d.ts

@@ -0,0 +1,17 @@
+import type { Permissions } from "@webiny/app-admin/exports/admin/security.js";
+import { TM_PERMISSIONS_SCHEMA } from "../../../admin/domain/permissionsSchema.js";
+export declare const TmPermissions: import("@webiny/di").Abstraction<{
+    canAccess: (entityId: never) => boolean;
+    canAction: (action: string, entityId: never) => boolean;
+} & {
+    canRead: (entityId: string) => boolean;
+    canCreate: (entityId: string) => boolean;
+    canEdit: (entityId: string, item?: import("@webiny/app-admin/permissions").OwnableItem) => boolean;
+    canDelete: (entityId: string, item?: import("@webiny/app-admin/permissions").OwnableItem) => boolean;
+} & {
+    canPublish: (entityId: string) => boolean;
+    canUnpublish: (entityId: string) => boolean;
+}>;
+export declare namespace TmPermissions {
+    type Interface = Permissions<typeof TM_PERMISSIONS_SCHEMA>;
+}

package/admin/features/permissions/abstractions.js

@@ -0,0 +1,6 @@
+import { createPermissionsAbstraction } from "@webiny/app-admin/exports/admin/security.js";
+import { TM_PERMISSIONS_SCHEMA } from "../../domain/permissionsSchema.js";
+const TmPermissions = createPermissionsAbstraction(TM_PERMISSIONS_SCHEMA);
+export { TmPermissions };
+
+//# sourceMappingURL=abstractions.js.map

package/admin/features/permissions/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/features/permissions/abstractions.js","sources":["../../../../src/admin/features/permissions/abstractions.ts"],"sourcesContent":["import { createPermissionsAbstraction } from \"@webiny/app-admin/exports/admin/security.js\";\nimport type { Permissions } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { TM_PERMISSIONS_SCHEMA } from \"~/admin/domain/permissionsSchema.js\";\n\nexport const TmPermissions = createPermissionsAbstraction(TM_PERMISSIONS_SCHEMA);\n\nexport namespace TmPermissions {\n    export type Interface = Permissions<typeof TM_PERMISSIONS_SCHEMA>;\n}\n"],"names":["TmPermissions","createPermissionsAbstraction","TM_PERMISSIONS_SCHEMA"],"mappings":";;AAIO,MAAMA,gBAAgBC,6BAA6BC"}

package/admin/features/permissions/feature.d.ts

@@ -0,0 +1,14 @@
+export declare const TmPermissionsFeature: import("@webiny/feature/admin/createFeature.js").FeatureDefinition<{
+    permissions: {
+        canAccess: (entityId: never) => boolean;
+        canAction: (action: string, entityId: never) => boolean;
+    } & {
+        canRead: (entityId: string) => boolean;
+        canCreate: (entityId: string) => boolean;
+        canEdit: (entityId: string, item?: import("@webiny/app-admin/index.js").OwnableItem) => boolean;
+        canDelete: (entityId: string, item?: import("@webiny/app-admin/index.js").OwnableItem) => boolean;
+    } & {
+        canPublish: (entityId: string) => boolean;
+        canUnpublish: (entityId: string) => boolean;
+    };
+}, []>;

package/admin/features/permissions/feature.js

@@ -0,0 +1,7 @@
+import { createPermissionsFeature } from "@webiny/app-admin/exports/admin/security.js";
+import { TM_PERMISSIONS_SCHEMA } from "../../domain/permissionsSchema.js";
+import { TmPermissions } from "./abstractions.js";
+const TmPermissionsFeature = createPermissionsFeature(TM_PERMISSIONS_SCHEMA, TmPermissions);
+export { TmPermissionsFeature };
+
+//# sourceMappingURL=feature.js.map

package/admin/features/permissions/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin/features/permissions/feature.js","sources":["../../../../src/admin/features/permissions/feature.ts"],"sourcesContent":["import { createPermissionsFeature } from \"@webiny/app-admin/exports/admin/security.js\";\nimport { TM_PERMISSIONS_SCHEMA } from \"~/admin/domain/permissionsSchema.js\";\nimport { TmPermissions } from \"./abstractions.js\";\n\nexport const TmPermissionsFeature = createPermissionsFeature(TM_PERMISSIONS_SCHEMA, TmPermissions);\n"],"names":["TmPermissionsFeature","createPermissionsFeature","TM_PERMISSIONS_SCHEMA","TmPermissions"],"mappings":";;;AAIO,MAAMA,uBAAuBC,yBAAyBC,uBAAuBC"}

package/admin/types.d.ts

@@ -0,0 +1,7 @@
+import { CmsContentEntry } from "@webiny/app-headless-cms/types.js";
+import type { TenantValues } from "../shared/Tenant.js";
+type BaseEntry = Omit<CmsContentEntry, "values">;
+export interface TenantEntry extends BaseEntry {
+    values: TenantValues;
+}
+export {};

package/api/Extension.d.ts

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

package/api/Extension.js

@@ -0,0 +1,39 @@
+import { createFeature } from "@webiny/feature/api";
+import TenantModel from "./domain/TenantModel.js";
+import { CreateAndInstallTenantFeature } from "./features/CreateAndInstallTenant/feature.js";
+import { CreateTenantFeature } from "./features/CreateTenant/feature.js";
+import { DisableTenantFeature } from "./features/DisableTenant/feature.js";
+import { EnableTenantFeature } from "./features/EnableTenant/feature.js";
+import { GetTenantByIdFeature } from "./features/GetTenantById/feature.js";
+import { GetCurrentTenantFeature } from "./features/GetCurrentTenant/feature.js";
+import { UpdateTenantFeature } from "./features/UpdateTenant/feature.js";
+import { DeleteTenantOnEntryDeleteFeature } from "./features/DeleteTenantOnEntryDelete/feature.js";
+import InstallTenantSchema from "./graphql/InstallTenantSchema.js";
+import CreateTenantSchema from "./graphql/CreateTenantSchema.js";
+import DisableTenantSchema from "./graphql/DisableTenantSchema.js";
+import EnableTenantSchema from "./graphql/EnableTenantSchema.js";
+import GetCurrentTenantSchema from "./graphql/GetCurrentTenantSchema.js";
+import { AddCmsPermissionsFeature } from "./features/AddCmsPermissions/feature.js";
+const Extension = createFeature({
+    name: "TenantManagement",
+    register (container) {
+        container.register(TenantModel);
+        container.register(InstallTenantSchema);
+        container.register(CreateTenantSchema);
+        container.register(DisableTenantSchema);
+        container.register(EnableTenantSchema);
+        container.register(GetCurrentTenantSchema);
+        CreateAndInstallTenantFeature.register(container);
+        CreateTenantFeature.register(container);
+        DisableTenantFeature.register(container);
+        EnableTenantFeature.register(container);
+        GetTenantByIdFeature.register(container);
+        GetCurrentTenantFeature.register(container);
+        UpdateTenantFeature.register(container);
+        DeleteTenantOnEntryDeleteFeature.register(container);
+        AddCmsPermissionsFeature.register(container);
+    }
+});
+export { Extension };
+
+//# sourceMappingURL=Extension.js.map

package/api/Extension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/Extension.js","sources":["../../src/api/Extension.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport TenantModel from \"./domain/TenantModel.js\";\nimport { CreateAndInstallTenantFeature } from \"./features/CreateAndInstallTenant/feature.js\";\nimport { CreateTenantFeature } from \"./features/CreateTenant/feature.js\";\nimport { DisableTenantFeature } from \"./features/DisableTenant/feature.js\";\nimport { EnableTenantFeature } from \"./features/EnableTenant/feature.js\";\nimport { GetTenantByIdFeature } from \"./features/GetTenantById/feature.js\";\nimport { GetCurrentTenantFeature } from \"./features/GetCurrentTenant/feature.js\";\nimport { UpdateTenantFeature } from \"./features/UpdateTenant/feature.js\";\nimport { DeleteTenantOnEntryDeleteFeature } from \"./features/DeleteTenantOnEntryDelete/feature.js\";\nimport InstallTenantSchema from \"./graphql/InstallTenantSchema.js\";\nimport CreateTenantSchema from \"./graphql/CreateTenantSchema.js\";\nimport DisableTenantSchema from \"./graphql/DisableTenantSchema.js\";\nimport EnableTenantSchema from \"./graphql/EnableTenantSchema.js\";\nimport GetCurrentTenantSchema from \"./graphql/GetCurrentTenantSchema.js\";\nimport { AddCmsPermissionsFeature } from \"~/api/features/AddCmsPermissions/feature.js\";\n\nexport const Extension = createFeature({\n    name: \"TenantManagement\",\n    register(container) {\n        container.register(TenantModel);\n\n        //GraphQL\n        container.register(InstallTenantSchema);\n        container.register(CreateTenantSchema);\n        container.register(DisableTenantSchema);\n        container.register(EnableTenantSchema);\n        container.register(GetCurrentTenantSchema);\n\n        // Features\n        CreateAndInstallTenantFeature.register(container);\n        CreateTenantFeature.register(container);\n        DisableTenantFeature.register(container);\n        EnableTenantFeature.register(container);\n        GetTenantByIdFeature.register(container);\n        GetCurrentTenantFeature.register(container);\n        UpdateTenantFeature.register(container);\n        DeleteTenantOnEntryDeleteFeature.register(container);\n        AddCmsPermissionsFeature.register(container);\n    }\n});\n"],"names":["Extension","createFeature","container","TenantModel","InstallTenantSchema","CreateTenantSchema","DisableTenantSchema","EnableTenantSchema","GetCurrentTenantSchema","CreateAndInstallTenantFeature","CreateTenantFeature","DisableTenantFeature","EnableTenantFeature","GetTenantByIdFeature","GetCurrentTenantFeature","UpdateTenantFeature","DeleteTenantOnEntryDeleteFeature","AddCmsPermissionsFeature"],"mappings":";;;;;;;;;;;;;;;;AAiBO,MAAMA,YAAYC,cAAc;IACnC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QAGnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QAGnBC,8BAA8B,QAAQ,CAACP;QACvCQ,oBAAoB,QAAQ,CAACR;QAC7BS,qBAAqB,QAAQ,CAACT;QAC9BU,oBAAoB,QAAQ,CAACV;QAC7BW,qBAAqB,QAAQ,CAACX;QAC9BY,wBAAwB,QAAQ,CAACZ;QACjCa,oBAAoB,QAAQ,CAACb;QAC7Bc,iCAAiC,QAAQ,CAACd;QAC1Ce,yBAAyB,QAAQ,CAACf;IACtC;AACJ"}

package/api/domain/TenantId.d.ts

@@ -0,0 +1,3 @@
+export declare class TenantId {
+    static from(id?: string): string;
+}

package/api/domain/TenantId.js

@@ -0,0 +1,10 @@
+import { EntryId } from "@webiny/api-headless-cms/exports/api/cms/entry.js";
+class TenantId {
+    static from(id) {
+        if (id) return EntryId.from(id).id;
+        return EntryId.create().id;
+    }
+}
+export { TenantId };
+
+//# sourceMappingURL=TenantId.js.map

package/api/domain/TenantId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/TenantId.js","sources":["../../../src/api/domain/TenantId.ts"],"sourcesContent":["import { EntryId } from \"@webiny/api-headless-cms/exports/api/cms/entry.js\";\n\nexport class TenantId {\n    static from(id?: string) {\n        if (id) {\n            // Ensure we have a clean id, without the revision suffix.\n            return EntryId.from(id).id;\n        }\n\n        return EntryId.create().id;\n    }\n}\n"],"names":["TenantId","id","EntryId"],"mappings":";AAEO,MAAMA;IACT,OAAO,KAAKC,EAAW,EAAE;QACrB,IAAIA,IAEA,OAAOC,QAAQ,IAAI,CAACD,IAAI,EAAE;QAG9B,OAAOC,QAAQ,MAAM,GAAG,EAAE;IAC9B;AACJ"}

package/api/domain/TenantModel.d.ts

@@ -0,0 +1,11 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+import { TenantModelExtension } from "./TenantModelExtension.js";
+declare class TenantModelFactory implements ModelFactory.Interface {
+    private extensions;
+    constructor(extensions: TenantModelExtension.Interface[]);
+    execute(builder: ModelFactory.Builder): Promise<import("@webiny/api-headless-cms/features/modelBuilder/index.js").PublicModelBuilder[]>;
+}
+declare const _default: typeof TenantModelFactory & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/modelBuilder/abstractions.js").IModelFactory>;
+};
+export default _default;

package/api/domain/TenantModel.js

@@ -0,0 +1,68 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+import { TenantModelExtension } from "./TenantModelExtension.js";
+import { TENANT_MODEL_ID } from "../../shared/constants.js";
+class TenantModelFactory {
+    constructor(extensions){
+        this.extensions = extensions;
+    }
+    async execute(builder) {
+        const model = builder.public({
+            modelId: TENANT_MODEL_ID,
+            name: "Tenant",
+            group: "hidden"
+        }).description("Manage system tenants.").titleFieldId("name").icon("fas/building").singularApiName("Tenant").pluralApiName("Tenants").tags([
+            "$publishing:false",
+            "$hidden:true"
+        ]);
+        model.fields((fields)=>({
+                name: fields.text().label("Name").description("Enter a tenant name").required().renderer("textInput"),
+                description: fields.longText().label("Description").description("Enter a short tenant description").renderer("textarea").required(),
+                status: fields.text().label("Status").defaultValue("disabled").renderer("hidden").predefinedValues([
+                    {
+                        value: "enabled",
+                        label: "Enabled"
+                    },
+                    {
+                        value: "disabled",
+                        label: "Disabled"
+                    }
+                ]),
+                isInstalled: fields.boolean().label("Is installed?").renderer("hidden").defaultValue(false),
+                extensions: fields.object().renderer("passthrough")
+            })).layout([
+            [
+                "name"
+            ],
+            [
+                "description"
+            ],
+            [
+                "extensions"
+            ]
+        ]);
+        for (const modifier of this.extensions)model.fields((fields)=>{
+            const extensions = fields.extend().object();
+            modifier.execute(extensions);
+            return {
+                extensions
+            };
+        });
+        return [
+            model
+        ];
+    }
+}
+const TenantModel = ModelFactory.createImplementation({
+    implementation: TenantModelFactory,
+    dependencies: [
+        [
+            TenantModelExtension,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export default TenantModel;
+
+//# sourceMappingURL=TenantModel.js.map

package/api/domain/TenantModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/TenantModel.js","sources":["../../../src/api/domain/TenantModel.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\nimport { TenantModelExtension } from \"./TenantModelExtension.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\n\nclass TenantModelFactory implements ModelFactory.Interface {\n    constructor(private extensions: TenantModelExtension.Interface[]) {}\n\n    async execute(builder: ModelFactory.Builder) {\n        const model = builder\n            .public({\n                modelId: TENANT_MODEL_ID,\n                name: \"Tenant\",\n                group: \"hidden\"\n            })\n            .description(\"Manage system tenants.\")\n            .titleFieldId(\"name\")\n            .icon(\"fas/building\")\n            .singularApiName(\"Tenant\")\n            .pluralApiName(\"Tenants\")\n            .tags([\"$publishing:false\", \"$hidden:true\"]);\n\n        model\n            .fields(fields => ({\n                name: fields\n                    .text()\n                    .label(\"Name\")\n                    .description(\"Enter a tenant name\")\n                    .required()\n                    .renderer(\"textInput\"),\n                description: fields\n                    .longText()\n                    .label(\"Description\")\n                    .description(\"Enter a short tenant description\")\n                    .renderer(\"textarea\")\n                    .required(),\n                status: fields\n                    .text()\n                    .label(\"Status\")\n                    .defaultValue(\"disabled\")\n                    .renderer(\"hidden\")\n                    .predefinedValues([\n                        {\n                            value: \"enabled\",\n                            label: \"Enabled\"\n                        },\n                        {\n                            value: \"disabled\",\n                            label: \"Disabled\"\n                        }\n                    ]),\n                isInstalled: fields\n                    .boolean()\n                    .label(\"Is installed?\")\n                    .renderer(\"hidden\")\n                    .defaultValue(false),\n                extensions: fields.object().renderer(\"passthrough\")\n            }))\n            .layout([[\"name\"], [\"description\"], [\"extensions\"]]);\n\n        for (const modifier of this.extensions) {\n            model.fields(fields => {\n                const extensions = fields.extend().object();\n                modifier.execute(extensions);\n\n                return { extensions };\n            });\n        }\n\n        return [model];\n    }\n}\n\nexport default ModelFactory.createImplementation({\n    implementation: TenantModelFactory,\n    dependencies: [[TenantModelExtension, { multiple: true }]]\n});\n"],"names":["TenantModelFactory","extensions","builder","model","TENANT_MODEL_ID","fields","modifier","ModelFactory","TenantModelExtension"],"mappings":";;;AAIA,MAAMA;IACF,YAAoBC,UAA4C,CAAE;aAA9CA,UAAU,GAAVA;IAA+C;IAEnE,MAAM,QAAQC,OAA6B,EAAE;QACzC,MAAMC,QAAQD,QACT,MAAM,CAAC;YACJ,SAASE;YACT,MAAM;YACN,OAAO;QACX,GACC,WAAW,CAAC,0BACZ,YAAY,CAAC,QACb,IAAI,CAAC,gBACL,eAAe,CAAC,UAChB,aAAa,CAAC,WACd,IAAI,CAAC;YAAC;YAAqB;SAAe;QAE/CD,MACK,MAAM,CAACE,CAAAA,SAAW;gBACf,MAAMA,OACD,IAAI,GACJ,KAAK,CAAC,QACN,WAAW,CAAC,uBACZ,QAAQ,GACR,QAAQ,CAAC;gBACd,aAAaA,OACR,QAAQ,GACR,KAAK,CAAC,eACN,WAAW,CAAC,oCACZ,QAAQ,CAAC,YACT,QAAQ;gBACb,QAAQA,OACH,IAAI,GACJ,KAAK,CAAC,UACN,YAAY,CAAC,YACb,QAAQ,CAAC,UACT,gBAAgB,CAAC;oBACd;wBACI,OAAO;wBACP,OAAO;oBACX;oBACA;wBACI,OAAO;wBACP,OAAO;oBACX;iBACH;gBACL,aAAaA,OACR,OAAO,GACP,KAAK,CAAC,iBACN,QAAQ,CAAC,UACT,YAAY,CAAC;gBAClB,YAAYA,OAAO,MAAM,GAAG,QAAQ,CAAC;YACzC,IACC,MAAM,CAAC;YAAC;gBAAC;aAAO;YAAE;gBAAC;aAAc;YAAE;gBAAC;aAAa;SAAC;QAEvD,KAAK,MAAMC,YAAY,IAAI,CAAC,UAAU,CAClCH,MAAM,MAAM,CAACE,CAAAA;YACT,MAAMJ,aAAaI,OAAO,MAAM,GAAG,MAAM;YACzCC,SAAS,OAAO,CAACL;YAEjB,OAAO;gBAAEA;YAAW;QACxB;QAGJ,OAAO;YAACE;SAAM;IAClB;AACJ;AAEA,oBAAeI,aAAa,oBAAoB,CAAC;IAC7C,gBAAgBP;IAChB,cAAc;QAAC;YAACQ;YAAsB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC9D"}

package/api/domain/TenantModelExtension.d.ts

@@ -0,0 +1,11 @@
+import { IObjectFieldBuilder } from "@webiny/api-headless-cms/features/modelBuilder/fields/ObjectFieldType.js";
+export type IExtension = Pick<IObjectFieldBuilder, "fields" | "layout">;
+export interface ITenantModelExtension {
+    execute(extension: IExtension): void;
+}
+/** Extend the tenant content model with custom fields. */
+export declare const TenantModelExtension: import("@webiny/di").Abstraction<ITenantModelExtension>;
+export declare namespace TenantModelExtension {
+    type Interface = ITenantModelExtension;
+    type Extension = IExtension;
+}

package/api/domain/TenantModelExtension.js

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

package/api/domain/TenantModelExtension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/TenantModelExtension.js","sources":["../../../src/api/domain/TenantModelExtension.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { IObjectFieldBuilder } from \"@webiny/api-headless-cms/features/modelBuilder/fields/ObjectFieldType.js\";\n\nexport type IExtension = Pick<IObjectFieldBuilder, \"fields\" | \"layout\">;\n\nexport interface ITenantModelExtension {\n    execute(extension: IExtension): void;\n}\n\n/** Extend the tenant content model with custom fields. */\nexport const TenantModelExtension =\n    createAbstraction<ITenantModelExtension>(\"TenantModelExtension\");\n\nexport namespace TenantModelExtension {\n    export type Interface = ITenantModelExtension;\n    export type Extension = IExtension;\n}\n"],"names":["TenantModelExtension","createAbstraction"],"mappings":";AAUO,MAAMA,uBACTC,kBAAyC"}

package/api/domain/errors.d.ts

@@ -0,0 +1,33 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class TenantNotFoundError extends BaseError {
+    readonly code: "Tenant/NotFound";
+    constructor(id: string);
+}
+export declare class TenantModelNotFoundError extends BaseError {
+    readonly code: "Tenant/ModelNotFound";
+    constructor();
+}
+export declare class TenantPersistenceError extends BaseError<{
+    error: Error;
+}> {
+    readonly code: "Tenant/Persist";
+    constructor(error: Error);
+}
+export declare class TenantCreationError extends BaseError<{
+    error: Error;
+}> {
+    readonly code: "Tenant/Create";
+    constructor(error: Error);
+}
+export declare class TenantInstallationError extends BaseError<{
+    error: Error;
+}> {
+    readonly code: "Tenant/Install";
+    constructor(error: Error);
+}
+export declare class TenantUpdateError extends BaseError<{
+    error: Error;
+}> {
+    readonly code: "Tenant/Update";
+    constructor(error: Error);
+}

package/api/domain/errors.js

@@ -0,0 +1,58 @@
+import { BaseError } from "@webiny/feature/api";
+class TenantNotFoundError extends BaseError {
+    constructor(id){
+        super({
+            message: `Tenant with id "${id}" was not found!`
+        }), this.code = "Tenant/NotFound";
+    }
+}
+class TenantModelNotFoundError extends BaseError {
+    constructor(){
+        super({
+            message: "Tenant model was not found!"
+        }), this.code = "Tenant/ModelNotFound";
+    }
+}
+class TenantPersistenceError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message,
+            data: {
+                error
+            }
+        }), this.code = "Tenant/Persist";
+    }
+}
+class TenantCreationError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message,
+            data: {
+                error
+            }
+        }), this.code = "Tenant/Create";
+    }
+}
+class TenantInstallationError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message,
+            data: {
+                error
+            }
+        }), this.code = "Tenant/Install";
+    }
+}
+class TenantUpdateError extends BaseError {
+    constructor(error){
+        super({
+            message: error.message,
+            data: {
+                error
+            }
+        }), this.code = "Tenant/Update";
+    }
+}
+export { TenantCreationError, TenantInstallationError, TenantModelNotFoundError, TenantNotFoundError, TenantPersistenceError, TenantUpdateError };
+
+//# sourceMappingURL=errors.js.map

package/api/domain/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/domain/errors.js","sources":["../../../src/api/domain/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class TenantNotFoundError extends BaseError {\n    override readonly code = \"Tenant/NotFound\" as const;\n\n    constructor(id: string) {\n        super({ message: `Tenant with id \"${id}\" was not found!` });\n    }\n}\n\nexport class TenantModelNotFoundError extends BaseError {\n    override readonly code = \"Tenant/ModelNotFound\" as const;\n\n    constructor() {\n        super({ message: `Tenant model was not found!` });\n    }\n}\n\nexport class TenantPersistenceError extends BaseError<{ error: Error }> {\n    override readonly code = \"Tenant/Persist\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message, data: { error } });\n    }\n}\n\nexport class TenantCreationError extends BaseError<{ error: Error }> {\n    override readonly code = \"Tenant/Create\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message, data: { error } });\n    }\n}\n\nexport class TenantInstallationError extends BaseError<{ error: Error }> {\n    override readonly code = \"Tenant/Install\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message, data: { error } });\n    }\n}\n\nexport class TenantUpdateError extends BaseError<{ error: Error }> {\n    override readonly code = \"Tenant/Update\" as const;\n\n    constructor(error: Error) {\n        super({ message: error.message, data: { error } });\n    }\n}\n"],"names":["TenantNotFoundError","BaseError","id","TenantModelNotFoundError","TenantPersistenceError","error","TenantCreationError","TenantInstallationError","TenantUpdateError"],"mappings":";AAEO,MAAMA,4BAA4BC;IAGrC,YAAYC,EAAU,CAAE;QACpB,KAAK,CAAC;YAAE,SAAS,CAAC,gBAAgB,EAAEA,GAAG,gBAAgB,CAAC;QAAC,SAH3C,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,iCAAiCF;IAG1C,aAAc;QACV,KAAK,CAAC;YAAE,SAAS;QAA8B,SAHjC,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMG,+BAA+BH;IAGxC,YAAYI,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;YAAE,MAAM;gBAAEA;YAAM;QAAE,SAHlC,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMC,4BAA4BL;IAGrC,YAAYI,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;YAAE,MAAM;gBAAEA;YAAM;QAAE,SAHlC,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAME,gCAAgCN;IAGzC,YAAYI,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;YAAE,MAAM;gBAAEA;YAAM;QAAE,SAHlC,IAAI,GAAG;IAIzB;AACJ;AAEO,MAAMG,0BAA0BP;IAGnC,YAAYI,KAAY,CAAE;QACtB,KAAK,CAAC;YAAE,SAASA,MAAM,OAAO;YAAE,MAAM;gBAAEA;YAAM;QAAE,SAHlC,IAAI,GAAG;IAIzB;AACJ"}

package/api/features/AddCmsPermissions/AddCmsPermissions.d.ts

@@ -0,0 +1,8 @@
+import { PermissionTransformer } from "@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js";
+declare class AddCmsPermissions implements PermissionTransformer.Interface {
+    execute(permission: PermissionTransformer.Permission): PermissionTransformer.Permission[] | PermissionTransformer.Permission;
+}
+declare const _default: typeof AddCmsPermissions & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js").IPermissionTransformer>;
+};
+export default _default;

package/api/features/AddCmsPermissions/AddCmsPermissions.js

@@ -0,0 +1,48 @@
+import { PermissionTransformer } from "@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js";
+import { TENANT_MODEL_ID } from "../../../shared/constants.js";
+class AddCmsPermissions {
+    execute(permission) {
+        if ("tm.*" !== permission.name) return permission;
+        return [
+            permission,
+            {
+                name: "cms.endpoint.manage",
+                _src: "tenant-manager"
+            },
+            {
+                name: "cms.contentModel",
+                own: false,
+                rwd: "r",
+                pw: "",
+                models: [
+                    TENANT_MODEL_ID
+                ],
+                _src: "tenant-manager"
+            },
+            {
+                name: "cms.contentModelGroup",
+                own: false,
+                rwd: "r",
+                pw: "",
+                groups: [
+                    "hidden"
+                ],
+                _src: "tenant-manager"
+            },
+            {
+                name: "cms.contentEntry",
+                own: false,
+                rwd: "rwd",
+                pw: "",
+                _src: "tenant-manager"
+            }
+        ];
+    }
+}
+const AddCmsPermissions_AddCmsPermissions = PermissionTransformer.createImplementation({
+    implementation: AddCmsPermissions,
+    dependencies: []
+});
+export default AddCmsPermissions_AddCmsPermissions;
+
+//# sourceMappingURL=AddCmsPermissions.js.map

package/api/features/AddCmsPermissions/AddCmsPermissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AddCmsPermissions/AddCmsPermissions.js","sources":["../../../../src/api/features/AddCmsPermissions/AddCmsPermissions.ts"],"sourcesContent":["import { PermissionTransformer } from \"@webiny/api-core/features/security/authorization/AuthorizationContext/abstractions.js\";\nimport { TENANT_MODEL_ID } from \"~/shared/constants.js\";\n\nclass AddCmsPermissions implements PermissionTransformer.Interface {\n    execute(permission: PermissionTransformer.Permission) {\n        if (permission.name !== \"tm.*\") {\n            return permission;\n        }\n\n        return [\n            permission,\n            {\n                name: \"cms.endpoint.manage\",\n                _src: \"tenant-manager\"\n            },\n            {\n                name: \"cms.contentModel\",\n                own: false,\n                rwd: \"r\",\n                pw: \"\",\n                models: [TENANT_MODEL_ID],\n                _src: \"tenant-manager\"\n            },\n            {\n                name: \"cms.contentModelGroup\",\n                own: false,\n                rwd: \"r\",\n                pw: \"\",\n                groups: [\"hidden\"],\n                _src: \"tenant-manager\"\n            },\n            {\n                name: \"cms.contentEntry\",\n                own: false,\n                rwd: \"rwd\",\n                pw: \"\",\n                _src: \"tenant-manager\"\n            }\n        ];\n    }\n}\n\nexport default PermissionTransformer.createImplementation({\n    implementation: AddCmsPermissions,\n    dependencies: []\n});\n"],"names":["AddCmsPermissions","permission","TENANT_MODEL_ID","PermissionTransformer"],"mappings":";;AAGA,MAAMA;IACF,QAAQC,UAA4C,EAAE;QAClD,IAAIA,AAAoB,WAApBA,WAAW,IAAI,EACf,OAAOA;QAGX,OAAO;YACHA;YACA;gBACI,MAAM;gBACN,MAAM;YACV;YACA;gBACI,MAAM;gBACN,KAAK;gBACL,KAAK;gBACL,IAAI;gBACJ,QAAQ;oBAACC;iBAAgB;gBACzB,MAAM;YACV;YACA;gBACI,MAAM;gBACN,KAAK;gBACL,KAAK;gBACL,IAAI;gBACJ,QAAQ;oBAAC;iBAAS;gBAClB,MAAM;YACV;YACA;gBACI,MAAM;gBACN,KAAK;gBACL,KAAK;gBACL,IAAI;gBACJ,MAAM;YACV;SACH;IACL;AACJ;AAEA,4CAAeC,sBAAsB,oBAAoB,CAAC;IACtD,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

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

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

package/api/features/AddCmsPermissions/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AddCmsPermissions/feature.js","sources":["../../../../src/api/features/AddCmsPermissions/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport AddCmsPermissions from \"./AddCmsPermissions.js\";\n\nexport const AddCmsPermissionsFeature = createFeature({\n    name: \"AddCmsPermissions\",\n    register(container) {\n        container.register(AddCmsPermissions);\n    }\n});\n"],"names":["AddCmsPermissionsFeature","createFeature","container","AddCmsPermissions"],"mappings":";;AAGO,MAAMA,2BAA2BC,cAAc;IAClD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/api/features/CreateAndInstallTenant/CreateAndInstallTenantUseCase.d.ts

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { Tenant } from "../../../shared/Tenant.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+import { UpdateTenantUseCase } from "../UpdateTenant/abstractions.js";
+import { CreateAndInstallTenantUseCase as UseCaseAbstraction } from "./abstractions.js";
+import * as Tenancy from "@webiny/api-core/exports/api/tenancy.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+declare class CreateAndInstallTenantUseCase implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private getTenantByIdUseCase;
+    private updateTenantUseCase;
+    private coreGetTenantById;
+    private coreCreateTenant;
+    private coreUpdateTenant;
+    private coreDeleteTenant;
+    private coreInstallTenant;
+    constructor(identityContext: IdentityContext.Interface, getTenantByIdUseCase: GetTenantByIdUseCase.Interface, updateTenantUseCase: UpdateTenantUseCase.Interface, coreGetTenantById: Tenancy.GetTenantByIdUseCase.Interface, coreCreateTenant: Tenancy.CreateTenantUseCase.Interface, coreUpdateTenant: Tenancy.UpdateTenantUseCase.Interface, coreDeleteTenant: Tenancy.DeleteTenantUseCase.Interface, coreInstallTenant: Tenancy.InstallTenantUseCase.Interface);
+    execute(tenantId: string): Promise<Result<Tenant, UseCaseAbstraction.Error>>;
+    private markTenantInstalled;
+}
+declare const _default: typeof CreateAndInstallTenantUseCase & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateAndInstallTenantUseCase>;
+};
+export default _default;

package/api/features/CreateAndInstallTenant/CreateAndInstallTenantUseCase.js

@@ -0,0 +1,81 @@
+import { Result } from "@webiny/feature/api";
+import { EntryId } from "@webiny/api-headless-cms/domain/contentEntry/EntryId.js";
+import { TenantCreationError, TenantInstallationError, TenantUpdateError } from "../../domain/errors.js";
+import { GetTenantByIdUseCase } from "../GetTenantById/abstractions.js";
+import { UpdateTenantUseCase } from "../UpdateTenant/abstractions.js";
+import { CreateAndInstallTenantUseCase } from "./abstractions.js";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import * as __rspack_external__webiny_api_core_exports_api_tenancy_js_0fb78d16 from "@webiny/api-core/exports/api/tenancy.js";
+class CreateAndInstallTenantUseCase_CreateAndInstallTenantUseCase {
+    constructor(identityContext, getTenantByIdUseCase, updateTenantUseCase, coreGetTenantById, coreCreateTenant, coreUpdateTenant, coreDeleteTenant, coreInstallTenant){
+        this.identityContext = identityContext;
+        this.getTenantByIdUseCase = getTenantByIdUseCase;
+        this.updateTenantUseCase = updateTenantUseCase;
+        this.coreGetTenantById = coreGetTenantById;
+        this.coreCreateTenant = coreCreateTenant;
+        this.coreUpdateTenant = coreUpdateTenant;
+        this.coreDeleteTenant = coreDeleteTenant;
+        this.coreInstallTenant = coreInstallTenant;
+    }
+    async execute(tenantId) {
+        if (!this.identityContext.getPermission("tm.tenant")) return Result.fail(new NotAuthorizedError({
+            message: "Not authorized to create tenants!"
+        }));
+        const entryId = EntryId.from(tenantId);
+        const tenantResult = await this.getTenantByIdUseCase.execute(entryId.id);
+        if (tenantResult.isFail()) return Result.fail(tenantResult.error);
+        const tenant = tenantResult.value;
+        const existingTenantResult = await this.coreGetTenantById.execute(tenant.id);
+        if (existingTenantResult.isOk()) {
+            await this.coreUpdateTenant.execute(tenant.id, {
+                name: tenant.values.name,
+                description: tenant.values.description,
+                status: "enabled"
+            });
+            return this.markTenantInstalled(tenant);
+        }
+        const createTenantResult = await this.coreCreateTenant.execute({
+            id: entryId.id,
+            name: tenant.values.name,
+            parent: "root",
+            description: tenant.values.name,
+            tags: []
+        });
+        if (createTenantResult.isFail()) return Result.fail(new TenantCreationError(createTenantResult.error));
+        const createdTenant = createTenantResult.value;
+        const installResult = await this.coreInstallTenant.execute({
+            tenant: createdTenant,
+            installationInput: []
+        });
+        if (installResult.isFail()) {
+            await this.coreDeleteTenant.execute(createdTenant.id);
+            return Result.fail(new TenantInstallationError(installResult.error));
+        }
+        return this.markTenantInstalled(tenant);
+    }
+    async markTenantInstalled(tenant) {
+        const updateResult = await this.updateTenantUseCase.execute(tenant.id, {
+            status: "enabled",
+            isInstalled: true
+        });
+        if (updateResult.isFail()) return Result.fail(new TenantUpdateError(updateResult.error));
+        return Result.ok(updateResult.value);
+    }
+}
+const CreateAndInstallTenant_CreateAndInstallTenantUseCase = CreateAndInstallTenantUseCase.createImplementation({
+    implementation: CreateAndInstallTenantUseCase_CreateAndInstallTenantUseCase,
+    dependencies: [
+        IdentityContext,
+        GetTenantByIdUseCase,
+        UpdateTenantUseCase,
+        __rspack_external__webiny_api_core_exports_api_tenancy_js_0fb78d16.GetTenantByIdUseCase,
+        __rspack_external__webiny_api_core_exports_api_tenancy_js_0fb78d16.CreateTenantUseCase,
+        __rspack_external__webiny_api_core_exports_api_tenancy_js_0fb78d16.UpdateTenantUseCase,
+        __rspack_external__webiny_api_core_exports_api_tenancy_js_0fb78d16.DeleteTenantUseCase,
+        __rspack_external__webiny_api_core_exports_api_tenancy_js_0fb78d16.InstallTenantUseCase
+    ]
+});
+export default CreateAndInstallTenant_CreateAndInstallTenantUseCase;
+
+//# sourceMappingURL=CreateAndInstallTenantUseCase.js.map