@webiny/cognito 0.0.0-unstable.0d717d18dd

package/api/domain/errors.js

@@ -0,0 +1,44 @@
+import { BaseError } from "@webiny/feature/api";
+class CognitoAccountExistsError extends BaseError {
+    constructor(email){
+        super({
+            message: "An account with this email already exists in your Cognito User Pool.",
+            data: {
+                email
+            }
+        }), this.code = "Cognito/Account/Exists";
+    }
+}
+class CognitoCreateUserError extends BaseError {
+    constructor(error){
+        super({
+            message: `Failed to create user in Cognito: ${error.message}`,
+            data: {
+                error
+            }
+        }), this.code = "Cognito/User/Create";
+    }
+}
+class CognitoUpdateUserError extends BaseError {
+    constructor(error){
+        super({
+            message: `Failed to update user in Cognito: ${error.message}`,
+            data: {
+                error
+            }
+        }), this.code = "Cognito/User/Update";
+    }
+}
+class CognitoDeleteUserError extends BaseError {
+    constructor(error){
+        super({
+            message: `Failed to delete user from Cognito: ${error.message}`,
+            data: {
+                error
+            }
+        }), this.code = "Cognito/User/Delete";
+    }
+}
+export { CognitoAccountExistsError, CognitoCreateUserError, CognitoDeleteUserError, CognitoUpdateUserError };
+
+//# 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\n/**\n * Error when a user already exists in Cognito User Pool\n */\nexport class CognitoAccountExistsError extends BaseError<{ email: string }> {\n    override readonly code = \"Cognito/Account/Exists\" as const;\n\n    constructor(email: string) {\n        super({\n            message: `An account with this email already exists in your Cognito User Pool.`,\n            data: { email }\n        });\n    }\n}\n\n/**\n * Error when creating a user in Cognito fails\n */\nexport class CognitoCreateUserError extends BaseError<{ error: Error }> {\n    override readonly code = \"Cognito/User/Create\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Failed to create user in Cognito: ${error.message}`,\n            data: { error }\n        });\n    }\n}\n\n/**\n * Error when updating a user in Cognito fails\n */\nexport class CognitoUpdateUserError extends BaseError<{ error: Error }> {\n    override readonly code = \"Cognito/User/Update\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Failed to update user in Cognito: ${error.message}`,\n            data: { error }\n        });\n    }\n}\n\n/**\n * Error when deleting a user from Cognito fails\n */\nexport class CognitoDeleteUserError extends BaseError<{ error: Error }> {\n    override readonly code = \"Cognito/User/Delete\" as const;\n\n    constructor(error: Error) {\n        super({\n            message: `Failed to delete user from Cognito: ${error.message}`,\n            data: { error }\n        });\n    }\n}\n"],"names":["CognitoAccountExistsError","BaseError","email","CognitoCreateUserError","error","CognitoUpdateUserError","CognitoDeleteUserError"],"mappings":";AAKO,MAAMA,kCAAkCC;IAG3C,YAAYC,KAAa,CAAE;QACvB,KAAK,CAAC;YACF,SAAS;YACT,MAAM;gBAAEA;YAAM;QAClB,SANc,IAAI,GAAG;IAOzB;AACJ;AAKO,MAAMC,+BAA+BF;IAGxC,YAAYG,KAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAAS,CAAC,kCAAkC,EAAEA,MAAM,OAAO,EAAE;YAC7D,MAAM;gBAAEA;YAAM;QAClB,SANc,IAAI,GAAG;IAOzB;AACJ;AAKO,MAAMC,+BAA+BJ;IAGxC,YAAYG,KAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAAS,CAAC,kCAAkC,EAAEA,MAAM,OAAO,EAAE;YAC7D,MAAM;gBAAEA;YAAM;QAClB,SANc,IAAI,GAAG;IAOzB;AACJ;AAKO,MAAME,+BAA+BL;IAGxC,YAAYG,KAAY,CAAE;QACtB,KAAK,CAAC;YACF,SAAS,CAAC,oCAAoC,EAAEA,MAAM,OAAO,EAAE;YAC/D,MAAM;gBAAEA;YAAM;QAClB,SANc,IAAI,GAAG;IAOzB;AACJ"}

package/api/features/CognitoIdp/CognitoIdentityProvider.d.ts

@@ -0,0 +1,15 @@
+import { OidcIdentityProvider } from "@webiny/api-core/idp";
+import { CognitoIdpConfig } from "./abstractions.js";
+declare class CognitoIdentityProviderImpl implements OidcIdentityProvider.Interface {
+    private config;
+    clientId: string;
+    issuer: string;
+    constructor(config: CognitoIdpConfig.Interface | undefined);
+    isApplicable(token: OidcIdentityProvider.JwtPayload): boolean;
+    getIdentity(token: OidcIdentityProvider.JwtPayload): Promise<OidcIdentityProvider.IdentityData>;
+    verifyTokenClaims(token: OidcIdentityProvider.JwtPayload): Promise<void>;
+}
+export declare const CognitoIdentityProvider: typeof CognitoIdentityProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/idp/abstractions.js").IOidcIdentityProvider>;
+};
+export {};

package/api/features/CognitoIdp/CognitoIdentityProvider.js

@@ -0,0 +1,63 @@
+import { OidcIdentityProvider } from "@webiny/api-core/idp";
+import { CognitoIdpConfig } from "./abstractions.js";
+class CognitoIdentityProviderImpl {
+    constructor(config){
+        this.config = config;
+        const region = String(process.env.COGNITO_REGION);
+        const userPoolId = String(process.env.COGNITO_USER_POOL_ID);
+        this.clientId = String(process.env.COGNITO_CLIENT_ID);
+        this.issuer = `https://cognito-idp.${region}.amazonaws.com/${userPoolId}`;
+    }
+    isApplicable(token) {
+        const issuer = token.iss;
+        if (!issuer) return false;
+        return issuer === this.issuer;
+    }
+    async getIdentity(token) {
+        const isFederated = Array.isArray(token.identities) && token.identities.length > 0;
+        const customId = token["custom:id"];
+        const givenName = token["given_name"];
+        const familyName = token["family_name"];
+        const email = token["email"];
+        const defaultIdentity = {
+            id: customId || token.sub || "",
+            displayName: `${givenName || ""} ${familyName || ""}`.trim() || email || "Unknown User",
+            type: "admin",
+            profile: {
+                email: email || "",
+                firstName: givenName || "",
+                lastName: familyName || "",
+                external: isFederated
+            }
+        };
+        const customIdentity = this.config ? await this.config.getIdentity(token) : null;
+        if (!customIdentity) return defaultIdentity;
+        return {
+            ...defaultIdentity,
+            ...customIdentity,
+            type: "admin",
+            profile: {
+                ...defaultIdentity.profile,
+                ...customIdentity.profile,
+                external: isFederated
+            }
+        };
+    }
+    async verifyTokenClaims(token) {
+        if (this.config?.verifyTokenClaims) await this.config.verifyTokenClaims(token);
+    }
+}
+const CognitoIdentityProvider = OidcIdentityProvider.createImplementation({
+    implementation: CognitoIdentityProviderImpl,
+    dependencies: [
+        [
+            CognitoIdpConfig,
+            {
+                optional: true
+            }
+        ]
+    ]
+});
+export { CognitoIdentityProvider };
+
+//# sourceMappingURL=CognitoIdentityProvider.js.map

package/api/features/CognitoIdp/CognitoIdentityProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CognitoIdp/CognitoIdentityProvider.js","sources":["../../../../src/api/features/CognitoIdp/CognitoIdentityProvider.ts"],"sourcesContent":["import { OidcIdentityProvider } from \"@webiny/api-core/idp\";\nimport { CognitoIdpConfig } from \"./abstractions.js\";\n\nclass CognitoIdentityProviderImpl implements OidcIdentityProvider.Interface {\n    public clientId: string;\n    public issuer: string;\n\n    constructor(private config: CognitoIdpConfig.Interface | undefined) {\n        const region = String(process.env.COGNITO_REGION);\n        const userPoolId = String(process.env.COGNITO_USER_POOL_ID);\n        this.clientId = String(process.env.COGNITO_CLIENT_ID);\n        this.issuer = `https://cognito-idp.${region}.amazonaws.com/${userPoolId}`;\n    }\n\n    isApplicable(token: OidcIdentityProvider.JwtPayload) {\n        const issuer = token.iss as string;\n        if (!issuer) {\n            return false;\n        }\n\n        return issuer === this.issuer;\n    }\n\n    async getIdentity(\n        token: OidcIdentityProvider.JwtPayload\n    ): Promise<OidcIdentityProvider.IdentityData> {\n        const isFederated = Array.isArray(token.identities) && token.identities.length > 0;\n\n        const customId = token[\"custom:id\"] as string | undefined;\n        const givenName = token[\"given_name\"] as string | undefined;\n        const familyName = token[\"family_name\"] as string | undefined;\n        const email = token[\"email\"] as string | undefined;\n\n        const defaultIdentity: OidcIdentityProvider.IdentityData = {\n            id: customId || token.sub || \"\",\n            displayName: `${givenName || \"\"} ${familyName || \"\"}`.trim() || email || \"Unknown User\",\n            type: \"admin\",\n            profile: {\n                email: email || \"\",\n                firstName: givenName || \"\",\n                lastName: familyName || \"\",\n                external: isFederated\n            }\n        };\n\n        const customIdentity = this.config ? await this.config.getIdentity(token) : null;\n\n        if (!customIdentity) {\n            return defaultIdentity;\n        }\n\n        return {\n            ...defaultIdentity,\n            ...customIdentity,\n            type: \"admin\",\n            profile: {\n                ...defaultIdentity.profile,\n                ...customIdentity.profile,\n                external: isFederated\n            }\n        };\n    }\n\n    async verifyTokenClaims(token: OidcIdentityProvider.JwtPayload): Promise<void> {\n        if (this.config?.verifyTokenClaims) {\n            await this.config.verifyTokenClaims(token);\n        }\n    }\n}\n\nexport const CognitoIdentityProvider = OidcIdentityProvider.createImplementation({\n    implementation: CognitoIdentityProviderImpl,\n    dependencies: [[CognitoIdpConfig, { optional: true }]]\n});\n"],"names":["CognitoIdentityProviderImpl","config","region","String","process","userPoolId","token","issuer","isFederated","Array","customId","givenName","familyName","email","defaultIdentity","customIdentity","CognitoIdentityProvider","OidcIdentityProvider","CognitoIdpConfig"],"mappings":";;AAGA,MAAMA;IAIF,YAAoBC,MAA8C,CAAE;aAAhDA,MAAM,GAANA;QAChB,MAAMC,SAASC,OAAOC,QAAQ,GAAG,CAAC,cAAc;QAChD,MAAMC,aAAaF,OAAOC,QAAQ,GAAG,CAAC,oBAAoB;QAC1D,IAAI,CAAC,QAAQ,GAAGD,OAAOC,QAAQ,GAAG,CAAC,iBAAiB;QACpD,IAAI,CAAC,MAAM,GAAG,CAAC,oBAAoB,EAAEF,OAAO,eAAe,EAAEG,YAAY;IAC7E;IAEA,aAAaC,KAAsC,EAAE;QACjD,MAAMC,SAASD,MAAM,GAAG;QACxB,IAAI,CAACC,QACD,OAAO;QAGX,OAAOA,WAAW,IAAI,CAAC,MAAM;IACjC;IAEA,MAAM,YACFD,KAAsC,EACI;QAC1C,MAAME,cAAcC,MAAM,OAAO,CAACH,MAAM,UAAU,KAAKA,MAAM,UAAU,CAAC,MAAM,GAAG;QAEjF,MAAMI,WAAWJ,KAAK,CAAC,YAAY;QACnC,MAAMK,YAAYL,KAAK,CAAC,aAAa;QACrC,MAAMM,aAAaN,KAAK,CAAC,cAAc;QACvC,MAAMO,QAAQP,KAAK,CAAC,QAAQ;QAE5B,MAAMQ,kBAAqD;YACvD,IAAIJ,YAAYJ,MAAM,GAAG,IAAI;YAC7B,aAAa,GAAGK,aAAa,GAAG,CAAC,EAAEC,cAAc,IAAI,CAAC,IAAI,MAAMC,SAAS;YACzE,MAAM;YACN,SAAS;gBACL,OAAOA,SAAS;gBAChB,WAAWF,aAAa;gBACxB,UAAUC,cAAc;gBACxB,UAAUJ;YACd;QACJ;QAEA,MAAMO,iBAAiB,IAAI,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAACT,SAAS;QAE5E,IAAI,CAACS,gBACD,OAAOD;QAGX,OAAO;YACH,GAAGA,eAAe;YAClB,GAAGC,cAAc;YACjB,MAAM;YACN,SAAS;gBACL,GAAGD,gBAAgB,OAAO;gBAC1B,GAAGC,eAAe,OAAO;gBACzB,UAAUP;YACd;QACJ;IACJ;IAEA,MAAM,kBAAkBF,KAAsC,EAAiB;QAC3E,IAAI,IAAI,CAAC,MAAM,EAAE,mBACb,MAAM,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAACA;IAE5C;AACJ;AAEO,MAAMU,0BAA0BC,qBAAqB,oBAAoB,CAAC;IAC7E,gBAAgBjB;IAChB,cAAc;QAAC;YAACkB;YAAkB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC1D"}

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

@@ -0,0 +1,15 @@
+import type jwt from "jsonwebtoken";
+import type { IdentityData } from "@webiny/api-core/idp";
+export type CognitoIdentity = Omit<IdentityData, "type"> & {
+    profile?: Omit<IdentityData["profile"], "external">;
+};
+export interface ICognitoIdpConfig {
+    getIdentity(token: jwt.JwtPayload): Promise<CognitoIdentity> | CognitoIdentity;
+    verifyTokenClaims?(token: jwt.JwtPayload): Promise<void> | void;
+}
+export declare const CognitoIdpConfig: import("@webiny/di").Abstraction<ICognitoIdpConfig>;
+export declare namespace CognitoIdpConfig {
+    type Interface = ICognitoIdpConfig;
+    type IdentityData = CognitoIdentity;
+    type JwtPayload = jwt.JwtPayload;
+}

package/api/features/CognitoIdp/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CognitoIdp/abstractions.js","sources":["../../../../src/api/features/CognitoIdp/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type jwt from \"jsonwebtoken\";\nimport type { IdentityData } from \"@webiny/api-core/idp\";\n\nexport type CognitoIdentity = Omit<IdentityData, \"type\"> & {\n    profile?: Omit<IdentityData[\"profile\"], \"external\">;\n};\n\nexport interface ICognitoIdpConfig {\n    getIdentity(token: jwt.JwtPayload): Promise<CognitoIdentity> | CognitoIdentity;\n    verifyTokenClaims?(token: jwt.JwtPayload): Promise<void> | void;\n}\n\nexport const CognitoIdpConfig = createAbstraction<ICognitoIdpConfig>(\"CognitoIdpConfig\");\n\nexport namespace CognitoIdpConfig {\n    export type Interface = ICognitoIdpConfig;\n    export type IdentityData = CognitoIdentity;\n    export type JwtPayload = jwt.JwtPayload;\n}\n"],"names":["CognitoIdpConfig","createAbstraction"],"mappings":";AAaO,MAAMA,mBAAmBC,kBAAqC"}

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

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

package/api/features/CognitoIdp/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CognitoIdp/feature.js","sources":["../../../../src/api/features/CognitoIdp/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CognitoIdentityProvider } from \"./CognitoIdentityProvider.js\";\n\nexport const CognitoIdpFeature = createFeature({\n    name: \"CognitoIdp\",\n    register(container) {\n        container.register(CognitoIdentityProvider).inSingletonScope();\n    }\n});\n"],"names":["CognitoIdpFeature","createFeature","container","CognitoIdentityProvider"],"mappings":";;AAGO,MAAMA,oBAAoBC,cAAc;IAC3C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,yBAAyB,gBAAgB;IAChE;AACJ"}

package/api/features/CognitoIdp/index.d.ts

@@ -0,0 +1,2 @@
+export { CognitoIdpConfig } from "./abstractions.js";
+export { CognitoIdpFeature } from "./feature.js";

package/api/features/CognitoIdp/index.js

@@ -0,0 +1,2 @@
+export { CognitoIdpConfig } from "./abstractions.js";
+export { CognitoIdpFeature } from "./feature.js";

package/api/features/CognitoService/CognitoService.d.ts

@@ -0,0 +1,20 @@
+import { CognitoConfig, CognitoService as ServiceAbstraction } from "./abstractions.js";
+declare class CognitoServiceImpl implements ServiceAbstraction.Interface {
+    private config;
+    private cognito;
+    constructor(config: CognitoConfig.Interface);
+    userExists(username: string): Promise<boolean>;
+    createUser(params: {
+        username: string;
+        temporaryPassword: string;
+        attributes: ServiceAbstraction.UserAttributes;
+    }): Promise<void>;
+    setEmailVerified(username: string): Promise<void>;
+    setPermanentPassword(username: string, password: string): Promise<void>;
+    updateUserAttributes(username: string, attributes: Record<string, string>): Promise<void>;
+    deleteUser(username: string): Promise<void>;
+}
+export declare const CognitoService: typeof CognitoServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICognitoService>;
+};
+export {};

package/api/features/CognitoService/CognitoService.js

@@ -0,0 +1,100 @@
+import { CognitoIdentityProvider } from "@webiny/aws-sdk/client-cognito-identity-provider/index.js";
+import { CognitoConfig, CognitoService } from "./abstractions.js";
+class CognitoServiceImpl {
+    constructor(config){
+        this.config = config;
+        this.cognito = new CognitoIdentityProvider({
+            region: config.region
+        });
+    }
+    async userExists(username) {
+        try {
+            await this.cognito.adminGetUser({
+                Username: username,
+                UserPoolId: this.config.userPoolId
+            });
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async createUser(params) {
+        const createUserParams = {
+            UserPoolId: this.config.userPoolId,
+            Username: params.username,
+            DesiredDeliveryMediums: [],
+            ForceAliasCreation: false,
+            MessageAction: "SUPPRESS",
+            TemporaryPassword: params.temporaryPassword,
+            UserAttributes: [
+                {
+                    Name: "given_name",
+                    Value: params.attributes.givenName || ""
+                },
+                {
+                    Name: "family_name",
+                    Value: params.attributes.familyName || ""
+                },
+                {
+                    Name: "preferred_username",
+                    Value: params.attributes.preferredUsername
+                },
+                {
+                    Name: "email",
+                    Value: params.attributes.email
+                },
+                {
+                    Name: "custom:id",
+                    Value: params.attributes.customId
+                }
+            ]
+        };
+        await this.cognito.adminCreateUser(createUserParams);
+    }
+    async setEmailVerified(username) {
+        await this.cognito.adminUpdateUserAttributes({
+            UserPoolId: this.config.userPoolId,
+            Username: username,
+            UserAttributes: [
+                {
+                    Name: "email_verified",
+                    Value: "true"
+                }
+            ]
+        });
+    }
+    async setPermanentPassword(username, password) {
+        await this.cognito.adminSetUserPassword({
+            Permanent: true,
+            Password: password,
+            Username: username,
+            UserPoolId: this.config.userPoolId
+        });
+    }
+    async updateUserAttributes(username, attributes) {
+        const userAttributes = Object.entries(attributes).map(([name, value])=>({
+                Name: name,
+                Value: value
+            }));
+        await this.cognito.adminUpdateUserAttributes({
+            UserPoolId: this.config.userPoolId,
+            Username: username,
+            UserAttributes: userAttributes
+        });
+    }
+    async deleteUser(username) {
+        await this.cognito.adminDeleteUser({
+            UserPoolId: this.config.userPoolId,
+            Username: username
+        });
+    }
+}
+const CognitoService_CognitoService = CognitoService.createImplementation({
+    implementation: CognitoServiceImpl,
+    dependencies: [
+        CognitoConfig
+    ]
+});
+export { CognitoService_CognitoService as CognitoService };
+
+//# sourceMappingURL=CognitoService.js.map

package/api/features/CognitoService/CognitoService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CognitoService/CognitoService.js","sources":["../../../../src/api/features/CognitoService/CognitoService.ts"],"sourcesContent":["import type { AdminCreateUserRequest } from \"@webiny/aws-sdk/client-cognito-identity-provider/index.js\";\nimport { CognitoIdentityProvider } from \"@webiny/aws-sdk/client-cognito-identity-provider/index.js\";\nimport { CognitoConfig, CognitoService as ServiceAbstraction } from \"./abstractions.js\";\n\nclass CognitoServiceImpl implements ServiceAbstraction.Interface {\n    private cognito: CognitoIdentityProvider;\n\n    constructor(private config: CognitoConfig.Interface) {\n        this.cognito = new CognitoIdentityProvider({ region: config.region });\n    }\n\n    async userExists(username: string): Promise<boolean> {\n        try {\n            await this.cognito.adminGetUser({\n                Username: username,\n                UserPoolId: this.config.userPoolId\n            });\n            return true;\n        } catch {\n            // User does not exist\n            return false;\n        }\n    }\n\n    async createUser(params: {\n        username: string;\n        temporaryPassword: string;\n        attributes: ServiceAbstraction.UserAttributes;\n    }): Promise<void> {\n        const createUserParams: AdminCreateUserRequest = {\n            UserPoolId: this.config.userPoolId,\n            Username: params.username,\n            DesiredDeliveryMediums: [],\n            ForceAliasCreation: false,\n            MessageAction: \"SUPPRESS\",\n            TemporaryPassword: params.temporaryPassword,\n            UserAttributes: [\n                {\n                    Name: \"given_name\",\n                    Value: params.attributes.givenName || \"\"\n                },\n                {\n                    Name: \"family_name\",\n                    Value: params.attributes.familyName || \"\"\n                },\n                {\n                    Name: \"preferred_username\",\n                    Value: params.attributes.preferredUsername\n                },\n                {\n                    Name: \"email\",\n                    Value: params.attributes.email\n                },\n                {\n                    Name: \"custom:id\",\n                    Value: params.attributes.customId\n                }\n            ]\n        };\n\n        await this.cognito.adminCreateUser(createUserParams);\n    }\n\n    async setEmailVerified(username: string): Promise<void> {\n        await this.cognito.adminUpdateUserAttributes({\n            UserPoolId: this.config.userPoolId,\n            Username: username,\n            UserAttributes: [\n                {\n                    Name: \"email_verified\",\n                    Value: \"true\"\n                }\n            ]\n        });\n    }\n\n    async setPermanentPassword(username: string, password: string): Promise<void> {\n        await this.cognito.adminSetUserPassword({\n            Permanent: true,\n            Password: password,\n            Username: username,\n            UserPoolId: this.config.userPoolId\n        });\n    }\n\n    async updateUserAttributes(\n        username: string,\n        attributes: Record<string, string>\n    ): Promise<void> {\n        const userAttributes = Object.entries(attributes).map(([name, value]) => ({\n            Name: name,\n            Value: value\n        }));\n\n        await this.cognito.adminUpdateUserAttributes({\n            UserPoolId: this.config.userPoolId,\n            Username: username,\n            UserAttributes: userAttributes\n        });\n    }\n\n    async deleteUser(username: string): Promise<void> {\n        await this.cognito.adminDeleteUser({\n            UserPoolId: this.config.userPoolId,\n            Username: username\n        });\n    }\n}\n\nexport const CognitoService = ServiceAbstraction.createImplementation({\n    implementation: CognitoServiceImpl,\n    dependencies: [CognitoConfig]\n});\n"],"names":["CognitoServiceImpl","config","CognitoIdentityProvider","username","params","createUserParams","password","attributes","userAttributes","Object","name","value","CognitoService","ServiceAbstraction","CognitoConfig"],"mappings":";;AAIA,MAAMA;IAGF,YAAoBC,MAA+B,CAAE;aAAjCA,MAAM,GAANA;QAChB,IAAI,CAAC,OAAO,GAAG,IAAIC,wBAAwB;YAAE,QAAQD,OAAO,MAAM;QAAC;IACvE;IAEA,MAAM,WAAWE,QAAgB,EAAoB;QACjD,IAAI;YACA,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC;gBAC5B,UAAUA;gBACV,YAAY,IAAI,CAAC,MAAM,CAAC,UAAU;YACtC;YACA,OAAO;QACX,EAAE,OAAM;YAEJ,OAAO;QACX;IACJ;IAEA,MAAM,WAAWC,MAIhB,EAAiB;QACd,MAAMC,mBAA2C;YAC7C,YAAY,IAAI,CAAC,MAAM,CAAC,UAAU;YAClC,UAAUD,OAAO,QAAQ;YACzB,wBAAwB,EAAE;YAC1B,oBAAoB;YACpB,eAAe;YACf,mBAAmBA,OAAO,iBAAiB;YAC3C,gBAAgB;gBACZ;oBACI,MAAM;oBACN,OAAOA,OAAO,UAAU,CAAC,SAAS,IAAI;gBAC1C;gBACA;oBACI,MAAM;oBACN,OAAOA,OAAO,UAAU,CAAC,UAAU,IAAI;gBAC3C;gBACA;oBACI,MAAM;oBACN,OAAOA,OAAO,UAAU,CAAC,iBAAiB;gBAC9C;gBACA;oBACI,MAAM;oBACN,OAAOA,OAAO,UAAU,CAAC,KAAK;gBAClC;gBACA;oBACI,MAAM;oBACN,OAAOA,OAAO,UAAU,CAAC,QAAQ;gBACrC;aACH;QACL;QAEA,MAAM,IAAI,CAAC,OAAO,CAAC,eAAe,CAACC;IACvC;IAEA,MAAM,iBAAiBF,QAAgB,EAAiB;QACpD,MAAM,IAAI,CAAC,OAAO,CAAC,yBAAyB,CAAC;YACzC,YAAY,IAAI,CAAC,MAAM,CAAC,UAAU;YAClC,UAAUA;YACV,gBAAgB;gBACZ;oBACI,MAAM;oBACN,OAAO;gBACX;aACH;QACL;IACJ;IAEA,MAAM,qBAAqBA,QAAgB,EAAEG,QAAgB,EAAiB;QAC1E,MAAM,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC;YACpC,WAAW;YACX,UAAUA;YACV,UAAUH;YACV,YAAY,IAAI,CAAC,MAAM,CAAC,UAAU;QACtC;IACJ;IAEA,MAAM,qBACFA,QAAgB,EAChBI,UAAkC,EACrB;QACb,MAAMC,iBAAiBC,OAAO,OAAO,CAACF,YAAY,GAAG,CAAC,CAAC,CAACG,MAAMC,MAAM,GAAM;gBACtE,MAAMD;gBACN,OAAOC;YACX;QAEA,MAAM,IAAI,CAAC,OAAO,CAAC,yBAAyB,CAAC;YACzC,YAAY,IAAI,CAAC,MAAM,CAAC,UAAU;YAClC,UAAUR;YACV,gBAAgBK;QACpB;IACJ;IAEA,MAAM,WAAWL,QAAgB,EAAiB;QAC9C,MAAM,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC;YAC/B,YAAY,IAAI,CAAC,MAAM,CAAC,UAAU;YAClC,UAAUA;QACd;IACJ;AACJ;AAEO,MAAMS,gCAAiBC,eAAAA,oBAAuC,CAAC;IAClE,gBAAgBb;IAChB,cAAc;QAACc;KAAc;AACjC"}

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

@@ -0,0 +1,54 @@
+import type { BaseUserAttributes } from "@webiny/api-core/types/users.js";
+export interface AttributeGetter {
+    (user: BaseUserAttributes): string;
+}
+export interface ICognitoConfig {
+    region: string;
+    userPoolId: string;
+}
+export declare const CognitoConfig: import("@webiny/di").Abstraction<ICognitoConfig>;
+export declare namespace CognitoConfig {
+    type Interface = ICognitoConfig;
+}
+export interface CognitoUserAttributes {
+    givenName?: string;
+    familyName?: string;
+    preferredUsername: string;
+    email: string;
+    customId: string;
+}
+export interface ICognitoService {
+    /**
+     * Check if a user exists in Cognito User Pool
+     */
+    userExists(username: string): Promise<boolean>;
+    /**
+     * Create a new user in Cognito User Pool
+     */
+    createUser(params: {
+        username: string;
+        temporaryPassword: string;
+        attributes: CognitoUserAttributes;
+    }): Promise<void>;
+    /**
+     * Set email as verified for a user
+     */
+    setEmailVerified(username: string): Promise<void>;
+    /**
+     * Set a permanent password for a user
+     */
+    setPermanentPassword(username: string, password: string): Promise<void>;
+    /**
+     * Update user attributes in Cognito
+     */
+    updateUserAttributes(username: string, attributes: Record<string, string>): Promise<void>;
+    /**
+     * Delete a user from Cognito User Pool
+     */
+    deleteUser(username: string): Promise<void>;
+}
+export declare const CognitoService: import("@webiny/di").Abstraction<ICognitoService>;
+export declare namespace CognitoService {
+    type Interface = ICognitoService;
+    type UserAttributes = CognitoUserAttributes;
+}

package/api/features/CognitoService/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CognitoService/abstractions.js","sources":["../../../../src/api/features/CognitoService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { BaseUserAttributes } from \"@webiny/api-core/types/users.js\";\n\nexport interface AttributeGetter {\n    (user: BaseUserAttributes): string;\n}\n\nexport interface ICognitoConfig {\n    region: string;\n    userPoolId: string;\n}\n\nexport const CognitoConfig = createAbstraction<ICognitoConfig>(\"CognitoConfig\");\n\nexport namespace CognitoConfig {\n    export type Interface = ICognitoConfig;\n}\n\n// Cognito Service\n\nexport interface CognitoUserAttributes {\n    givenName?: string;\n    familyName?: string;\n    preferredUsername: string;\n    email: string;\n    customId: string;\n}\n\nexport interface ICognitoService {\n    /**\n     * Check if a user exists in Cognito User Pool\n     */\n    userExists(username: string): Promise<boolean>;\n\n    /**\n     * Create a new user in Cognito User Pool\n     */\n    createUser(params: {\n        username: string;\n        temporaryPassword: string;\n        attributes: CognitoUserAttributes;\n    }): Promise<void>;\n\n    /**\n     * Set email as verified for a user\n     */\n    setEmailVerified(username: string): Promise<void>;\n\n    /**\n     * Set a permanent password for a user\n     */\n    setPermanentPassword(username: string, password: string): Promise<void>;\n\n    /**\n     * Update user attributes in Cognito\n     */\n    updateUserAttributes(username: string, attributes: Record<string, string>): Promise<void>;\n\n    /**\n     * Delete a user from Cognito User Pool\n     */\n    deleteUser(username: string): Promise<void>;\n}\n\nexport const CognitoService = createAbstraction<ICognitoService>(\"CognitoService\");\nexport namespace CognitoService {\n    export type Interface = ICognitoService;\n    export type UserAttributes = CognitoUserAttributes;\n}\n"],"names":["CognitoConfig","createAbstraction","CognitoService"],"mappings":";AAYO,MAAMA,gBAAgBC,kBAAkC;AAoDxD,MAAMC,iBAAiBD,kBAAmC"}

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

@@ -0,0 +1,8 @@
+export type UserPoolConfig = {
+    region: string;
+    userPoolId: string;
+};
+export declare const CognitoServiceFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container, context: UserPoolConfig): void;
+};

package/api/features/CognitoService/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { CognitoService } from "./CognitoService.js";
+import { CognitoConfig } from "./abstractions.js";
+const CognitoServiceFeature = createFeature({
+    name: "cognitoService",
+    register (container, config) {
+        container.register(CognitoService).inSingletonScope();
+        container.registerInstance(CognitoConfig, config);
+    }
+});
+export { CognitoServiceFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CognitoService/feature.js","sources":["../../../../src/api/features/CognitoService/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CognitoService } from \"./CognitoService.js\";\nimport { CognitoConfig } from \"./abstractions.js\";\n\nexport type UserPoolConfig = {\n    region: string;\n    userPoolId: string;\n};\n\nexport const CognitoServiceFeature = createFeature<UserPoolConfig>({\n    name: \"cognitoService\",\n    register(container, config) {\n        container.register(CognitoService).inSingletonScope();\n\n        container.registerInstance(CognitoConfig, config);\n    }\n});\n"],"names":["CognitoServiceFeature","createFeature","container","config","CognitoService","CognitoConfig"],"mappings":";;;AASO,MAAMA,wBAAwBC,cAA8B;IAC/D,MAAM;IACN,UAASC,SAAS,EAAEC,MAAM;QACtBD,UAAU,QAAQ,CAACE,gBAAgB,gBAAgB;QAEnDF,UAAU,gBAAgB,CAACG,eAAeF;IAC9C;AACJ"}

package/api/features/CognitoService/index.d.ts

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/api/features/CognitoService/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/api/features/CreateUser/CreateUserUseCase.d.ts

@@ -0,0 +1,22 @@
+import { Result } from "@webiny/feature/api";
+import { AdminUsersRepository } from "@webiny/api-core/features/users/shared/abstractions.js";
+import type { AdminUser } from "@webiny/api-core/types/users.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { CreateUserUseCase as CoreCreateUser } from "@webiny/api-core/features/users/CreateUser/index.js";
+import { ListUsersUseCase } from "@webiny/api-core/features/users/ListUsers/index.js";
+import { CreateUserUseCase as UseCaseAbstraction } from "./abstractions.js";
+import type { CreateAdminUserInput } from "./abstractions.js";
+import { CognitoService } from "../../../api/features/CognitoService/index.js";
+declare class CreateUserUseCaseImpl implements UseCaseAbstraction.Interface {
+    private identityContext;
+    private cognitoService;
+    private createUserUseCase;
+    private listUsersUseCase;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, cognitoService: CognitoService.Interface, createUserUseCase: CoreCreateUser.Interface, listUsersUseCase: ListUsersUseCase.Interface, repository: AdminUsersRepository.Interface);
+    execute(input: CreateAdminUserInput): Promise<Result<AdminUser, UseCaseAbstraction.Error>>;
+}
+export declare const CreateUserUseCase: typeof CreateUserUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateUserUseCase>;
+};
+export {};

package/api/features/CreateUser/CreateUserUseCase.js

@@ -0,0 +1,80 @@
+import { Result } from "@webiny/feature/api";
+import { AdminUsersRepository } from "@webiny/api-core/features/users/shared/abstractions.js";
+import { NotAuthorizedError, UserValidationError } from "@webiny/api-core/features/users/shared/errors.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { CreateUserUseCase } from "@webiny/api-core/features/users/CreateUser/index.js";
+import { ListUsersUseCase } from "@webiny/api-core/features/users/ListUsers/index.js";
+import { CreateUserUseCase as external_abstractions_js_CreateUserUseCase } from "./abstractions.js";
+import { Username } from "../../domain/Username.js";
+import { CognitoAccountExistsError, CognitoCreateUserError } from "../../domain/errors.js";
+import { createAdminUserValidation } from "./schema.js";
+import { CognitoService } from "../CognitoService/index.js";
+class CreateUserUseCaseImpl {
+    constructor(identityContext, cognitoService, createUserUseCase, listUsersUseCase, repository){
+        this.identityContext = identityContext;
+        this.cognitoService = cognitoService;
+        this.createUserUseCase = createUserUseCase;
+        this.listUsersUseCase = listUsersUseCase;
+        this.repository = repository;
+    }
+    async execute(input) {
+        const permission = await this.identityContext.getPermission("adminUsers.user");
+        if (!permission) return Result.fail(new NotAuthorizedError());
+        const validation = createAdminUserValidation.safeParse(input);
+        if (!validation.success) return Result.fail(new UserValidationError(validation.error.issues[0].message));
+        const data = validation.data;
+        const { password, ...userDataWithoutPassword } = data;
+        const username = Username.fromUser(data);
+        const existingUserResult = await this.repository.get({
+            email: data.email
+        });
+        if (existingUserResult.isOk()) return Result.fail(new CognitoAccountExistsError(data.email));
+        let user;
+        try {
+            const userExists = await this.cognitoService.userExists(username);
+            if (userExists) return Result.fail(new CognitoAccountExistsError(data.email));
+            const createUserResult = await this.createUserUseCase.execute(userDataWithoutPassword);
+            if (createUserResult.isFail()) return Result.fail(createUserResult.error);
+            user = createUserResult.value;
+            await this.cognitoService.createUser({
+                username,
+                temporaryPassword: password,
+                attributes: {
+                    givenName: data.firstName,
+                    familyName: data.lastName,
+                    preferredUsername: username,
+                    email: username,
+                    customId: user.id
+                }
+            });
+            await this.cognitoService.setEmailVerified(username);
+            const usersResult = await this.listUsersUseCase.execute();
+            if (usersResult.isFail()) console.error(`Failed to list users: ${usersResult.error.message}`);
+            else {
+                const users = usersResult.value;
+                if (users.length <= 1) await this.cognitoService.setPermanentPassword(username, password);
+            }
+            return Result.ok(user);
+        } catch (cognitoError) {
+            if (user) try {
+                await this.repository.delete(user);
+            } catch (rollbackError) {
+                console.error("Failed to rollback user creation:", rollbackError);
+            }
+            return Result.fail(new CognitoCreateUserError(cognitoError));
+        }
+    }
+}
+const CreateUserUseCase_CreateUserUseCase = external_abstractions_js_CreateUserUseCase.createImplementation({
+    implementation: CreateUserUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        CognitoService,
+        CreateUserUseCase,
+        ListUsersUseCase,
+        AdminUsersRepository
+    ]
+});
+export { CreateUserUseCase_CreateUserUseCase as CreateUserUseCase };
+
+//# sourceMappingURL=CreateUserUseCase.js.map

package/api/features/CreateUser/CreateUserUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateUser/CreateUserUseCase.js","sources":["../../../../src/api/features/CreateUser/CreateUserUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { AdminUsersRepository } from \"@webiny/api-core/features/users/shared/abstractions.js\";\nimport {\n    NotAuthorizedError,\n    UserValidationError\n} from \"@webiny/api-core/features/users/shared/errors.js\";\nimport type { AdminUser } from \"@webiny/api-core/types/users.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { CreateUserUseCase as CoreCreateUser } from \"@webiny/api-core/features/users/CreateUser/index.js\";\nimport { ListUsersUseCase } from \"@webiny/api-core/features/users/ListUsers/index.js\";\n\nimport { CreateUserUseCase as UseCaseAbstraction } from \"./abstractions.js\";\nimport { Username } from \"~/api/domain/Username.js\";\nimport { CognitoAccountExistsError, CognitoCreateUserError } from \"~/api/domain/errors.js\";\nimport { createAdminUserValidation } from \"./schema.js\";\nimport type { CreateAdminUserInput } from \"./abstractions.js\";\nimport { CognitoService } from \"~/api/features/CognitoService/index.js\";\n\nclass CreateUserUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private cognitoService: CognitoService.Interface,\n        private createUserUseCase: CoreCreateUser.Interface,\n        private listUsersUseCase: ListUsersUseCase.Interface,\n        private repository: AdminUsersRepository.Interface\n    ) {}\n\n    async execute(\n        input: CreateAdminUserInput\n    ): Promise<Result<AdminUser, UseCaseAbstraction.Error>> {\n        const permission = await this.identityContext.getPermission(\"adminUsers.user\");\n        if (!permission) {\n            return Result.fail(new NotAuthorizedError());\n        }\n\n        // Validate input (including password)\n        const validation = createAdminUserValidation.safeParse(input);\n        if (!validation.success) {\n            return Result.fail(new UserValidationError(validation.error.issues[0].message));\n        }\n\n        const data = validation.data;\n        const { password, ...userDataWithoutPassword } = data;\n\n        const username = Username.fromUser(data);\n\n        // Check if user exists in database (faster than Cognito check)\n        const existingUserResult = await this.repository.get({ email: data.email });\n        if (existingUserResult.isOk()) {\n            return Result.fail(new CognitoAccountExistsError(data.email));\n        }\n\n        let user: AdminUser | undefined = undefined;\n\n        try {\n            // Check if user exists in Cognito\n            const userExists = await this.cognitoService.userExists(username);\n            if (userExists) {\n                return Result.fail(new CognitoAccountExistsError(data.email));\n            }\n            // Create user in api-core\n            const createUserResult = await this.createUserUseCase.execute(userDataWithoutPassword);\n            if (createUserResult.isFail()) {\n                return Result.fail(createUserResult.error);\n            }\n\n            user = createUserResult.value;\n\n            // Create user in Cognito\n            await this.cognitoService.createUser({\n                username,\n                temporaryPassword: password,\n                attributes: {\n                    givenName: data.firstName,\n                    familyName: data.lastName,\n                    preferredUsername: username,\n                    email: username,\n                    customId: user.id\n                }\n            });\n\n            // Set email as verified\n            await this.cognitoService.setEmailVerified(username);\n\n            // Check if this is the first user in the system, and if so, set permanent password\n            const usersResult = await this.listUsersUseCase.execute();\n            if (usersResult.isFail()) {\n                // Log error but don't fail the operation\n                console.error(`Failed to list users: ${usersResult.error.message}`);\n            } else {\n                const users = usersResult.value;\n                if (users.length <= 1) {\n                    // This is the first user, set permanent password\n                    await this.cognitoService.setPermanentPassword(username, password);\n                }\n            }\n\n            return Result.ok(user);\n        } catch (cognitoError) {\n            if (user) {\n                // Rollback: Delete user from api-core if Cognito creation failed\n                try {\n                    await this.repository.delete(user);\n                } catch (rollbackError) {\n                    console.error(\"Failed to rollback user creation:\", rollbackError);\n                }\n            }\n            return Result.fail(new CognitoCreateUserError(cognitoError as Error));\n        }\n    }\n}\n\nexport const CreateUserUseCase = UseCaseAbstraction.createImplementation({\n    implementation: CreateUserUseCaseImpl,\n    dependencies: [\n        IdentityContext,\n        CognitoService,\n        CoreCreateUser,\n        ListUsersUseCase,\n        AdminUsersRepository\n    ]\n});\n"],"names":["CreateUserUseCaseImpl","identityContext","cognitoService","createUserUseCase","listUsersUseCase","repository","input","permission","Result","NotAuthorizedError","validation","createAdminUserValidation","UserValidationError","data","password","userDataWithoutPassword","username","Username","existingUserResult","CognitoAccountExistsError","user","userExists","createUserResult","usersResult","console","users","cognitoError","rollbackError","CognitoCreateUserError","CreateUserUseCase","UseCaseAbstraction","IdentityContext","CognitoService","CoreCreateUser","ListUsersUseCase","AdminUsersRepository"],"mappings":";;;;;;;;;;;AAkBA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,cAAwC,EACxCC,iBAA2C,EAC3CC,gBAA4C,EAC5CC,UAA0C,CACpD;aALUJ,eAAe,GAAfA;aACAC,cAAc,GAAdA;aACAC,iBAAiB,GAAjBA;aACAC,gBAAgB,GAAhBA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QACFC,KAA2B,EACyB;QACpD,MAAMC,aAAa,MAAM,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC;QAC5D,IAAI,CAACA,YACD,OAAOC,OAAO,IAAI,CAAC,IAAIC;QAI3B,MAAMC,aAAaC,0BAA0B,SAAS,CAACL;QACvD,IAAI,CAACI,WAAW,OAAO,EACnB,OAAOF,OAAO,IAAI,CAAC,IAAII,oBAAoBF,WAAW,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO;QAGjF,MAAMG,OAAOH,WAAW,IAAI;QAC5B,MAAM,EAAEI,QAAQ,EAAE,GAAGC,yBAAyB,GAAGF;QAEjD,MAAMG,WAAWC,SAAS,QAAQ,CAACJ;QAGnC,MAAMK,qBAAqB,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC;YAAE,OAAOL,KAAK,KAAK;QAAC;QACzE,IAAIK,mBAAmB,IAAI,IACvB,OAAOV,OAAO,IAAI,CAAC,IAAIW,0BAA0BN,KAAK,KAAK;QAG/D,IAAIO;QAEJ,IAAI;YAEA,MAAMC,aAAa,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAACL;YACxD,IAAIK,YACA,OAAOb,OAAO,IAAI,CAAC,IAAIW,0BAA0BN,KAAK,KAAK;YAG/D,MAAMS,mBAAmB,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACP;YAC9D,IAAIO,iBAAiB,MAAM,IACvB,OAAOd,OAAO,IAAI,CAACc,iBAAiB,KAAK;YAG7CF,OAAOE,iBAAiB,KAAK;YAG7B,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC;gBACjCN;gBACA,mBAAmBF;gBACnB,YAAY;oBACR,WAAWD,KAAK,SAAS;oBACzB,YAAYA,KAAK,QAAQ;oBACzB,mBAAmBG;oBACnB,OAAOA;oBACP,UAAUI,KAAK,EAAE;gBACrB;YACJ;YAGA,MAAM,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAACJ;YAG3C,MAAMO,cAAc,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO;YACvD,IAAIA,YAAY,MAAM,IAElBC,QAAQ,KAAK,CAAC,CAAC,sBAAsB,EAAED,YAAY,KAAK,CAAC,OAAO,EAAE;iBAC/D;gBACH,MAAME,QAAQF,YAAY,KAAK;gBAC/B,IAAIE,MAAM,MAAM,IAAI,GAEhB,MAAM,IAAI,CAAC,cAAc,CAAC,oBAAoB,CAACT,UAAUF;YAEjE;YAEA,OAAON,OAAO,EAAE,CAACY;QACrB,EAAE,OAAOM,cAAc;YACnB,IAAIN,MAEA,IAAI;gBACA,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;YACjC,EAAE,OAAOO,eAAe;gBACpBH,QAAQ,KAAK,CAAC,qCAAqCG;YACvD;YAEJ,OAAOnB,OAAO,IAAI,CAAC,IAAIoB,uBAAuBF;QAClD;IACJ;AACJ;AAEO,MAAMG,sCAAoBC,2CAAAA,oBAAuC,CAAC;IACrE,gBAAgB9B;IAChB,cAAc;QACV+B;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,35 @@
+import type { Result } from "@webiny/feature/api";
+import type { AdminUser } from "@webiny/api-core/types/users.js";
+import type { NotAuthorizedError, EmailTakenError, UserValidationError } from "@webiny/api-core/features/users/shared/errors.js";
+import type { RepositoryError } from "@webiny/api-core/features/users/shared/abstractions.js";
+import type { CognitoAccountExistsError, CognitoCreateUserError } from "../../../api/domain/errors.js";
+export interface CreateAdminUserInput {
+    id?: string;
+    displayName?: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    password: string;
+    avatar?: Record<string, any> | null;
+    roles?: string[];
+    teams?: string[];
+}
+export interface ICreateUserUseCaseErrors {
+    authorization: NotAuthorizedError;
+    validation: UserValidationError;
+    emailTaken: EmailTakenError;
+    repository: RepositoryError;
+    cognitoAccountExists: CognitoAccountExistsError;
+    cognitoCreateUser: CognitoCreateUserError;
+}
+type CreateAdminUserError = ICreateUserUseCaseErrors[keyof ICreateUserUseCaseErrors];
+export interface ICreateUserUseCase {
+    execute(input: CreateAdminUserInput): Promise<Result<AdminUser, CreateAdminUserError>>;
+}
+export declare const CreateUserUseCase: import("@webiny/di").Abstraction<ICreateUserUseCase>;
+export declare namespace CreateUserUseCase {
+    type Interface = ICreateUserUseCase;
+    type Input = CreateAdminUserInput;
+    type Error = CreateAdminUserError;
+}
+export {};

package/api/features/CreateUser/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/CreateUser/abstractions.js","sources":["../../../../src/api/features/CreateUser/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { AdminUser } from \"@webiny/api-core/types/users.js\";\nimport type {\n    NotAuthorizedError,\n    EmailTakenError,\n    UserValidationError\n} from \"@webiny/api-core/features/users/shared/errors.js\";\nimport type { RepositoryError } from \"@webiny/api-core/features/users/shared/abstractions.js\";\nimport type { CognitoAccountExistsError, CognitoCreateUserError } from \"~/api/domain/errors.js\";\n\nexport interface CreateAdminUserInput {\n    id?: string;\n    displayName?: string;\n    email: string;\n    firstName?: string;\n    lastName?: string;\n    password: string;\n    avatar?: Record<string, any> | null;\n    roles?: string[];\n    teams?: string[];\n}\n\nexport interface ICreateUserUseCaseErrors {\n    authorization: NotAuthorizedError;\n    validation: UserValidationError;\n    emailTaken: EmailTakenError;\n    repository: RepositoryError;\n    cognitoAccountExists: CognitoAccountExistsError;\n    cognitoCreateUser: CognitoCreateUserError;\n}\n\ntype CreateAdminUserError = ICreateUserUseCaseErrors[keyof ICreateUserUseCaseErrors];\n\nexport interface ICreateUserUseCase {\n    execute(input: CreateAdminUserInput): Promise<Result<AdminUser, CreateAdminUserError>>;\n}\n\nexport const CreateUserUseCase = createAbstraction<ICreateUserUseCase>(\"CreateUserUseCase\");\n\nexport namespace CreateUserUseCase {\n    export type Interface = ICreateUserUseCase;\n    export type Input = CreateAdminUserInput;\n    export type Error = CreateAdminUserError;\n}\n"],"names":["CreateUserUseCase","createAbstraction"],"mappings":";AAsCO,MAAMA,oBAAoBC,kBAAsC"}

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

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