@bitblit/ratchet-warden-server 4.0.84-alpha

package/dist/cjs/server/warden-service.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WardenService = void 0;
+const server_1 = require("@simplewebauthn/server");
+const ratchet_warden_common_1 = require("@bitblit/ratchet-warden-common");
+const ratchet_aws_1 = require("@bitblit/ratchet-aws");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const warden_default_user_decoration_provider_1 = require("./provider/warden-default-user-decoration-provider");
+const warden_no_op_event_processing_provider_1 = require("./provider/warden-no-op-event-processing-provider");
+class WardenService {
+    constructor(inOptions) {
+        this.inOptions = inOptions;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(inOptions, 'options');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(inOptions.relyingPartyName, 'options.relyingPartyName');
+        ratchet_common_1.RequireRatchet.notNullUndefinedOrEmptyArray(inOptions.allowedOrigins, 'options.allowedOrigins');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(inOptions.storageProvider, 'options.storageProvider');
+        ratchet_common_1.RequireRatchet.notNullUndefinedOrEmptyArray(inOptions.messageSendingProviders, 'options.messageSendingProviders');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(inOptions.expiringCodeProvider, 'options.expiringCodeProvider');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(inOptions.jwtRatchet, 'options.jwtRatchet');
+        this.opts = Object.assign({ userTokenDataProvider: new warden_default_user_decoration_provider_1.WardenDefaultUserDecorationProvider(), eventProcessor: new warden_no_op_event_processing_provider_1.WardenNoOpEventProcessingProvider() }, inOptions);
+        this.expiringCodeRatchet = new ratchet_aws_1.ExpiringCodeRatchet(this.opts.expiringCodeProvider);
+    }
+    get options() {
+        return Object.assign({}, this.opts);
+    }
+    findEntryByContact(contact) {
+        return this.opts.storageProvider.findEntryByContact(contact);
+    }
+    async processCommandStringToString(cmdString, origin, loggedInUserId) {
+        let rval = null;
+        try {
+            const cmd = JSON.parse(cmdString);
+            const resp = await this.processCommandToResponse(cmd, origin, loggedInUserId);
+            if (resp === null) {
+                ratchet_common_1.Logger.warn('Response was null for %s %s %s', cmdString, origin, loggedInUserId);
+            }
+            else {
+                rval = JSON.stringify(resp);
+            }
+        }
+        catch (err) {
+            const errString = ratchet_common_1.ErrorRatchet.safeStringifyErr(err);
+            ratchet_common_1.Logger.error('Failed %s : %j', errString, cmdString, err);
+            rval = JSON.stringify({ error: errString });
+        }
+        return rval;
+    }
+    async processCommandToResponse(cmd, origin, loggedInUserId) {
+        let rval = null;
+        if (cmd) {
+            ratchet_common_1.Logger.info('Processing command : UserID: %s  Origin: %s Command: %j', loggedInUserId, origin, cmd);
+            if (cmd.sendExpiringValidationToken) {
+                rval = { sendExpiringValidationToken: await this.sendExpiringValidationToken(cmd.sendExpiringValidationToken) };
+            }
+            else if (cmd.generateWebAuthnAuthenticationChallengeForUserId) {
+                const tmp = await this.generateWebAuthnAuthenticationChallengeForUserId(cmd.generateWebAuthnAuthenticationChallengeForUserId, origin);
+                rval = { generateWebAuthnAuthenticationChallengeForUserId: { dataAsJson: JSON.stringify(tmp) } };
+            }
+            else if (cmd.createAccount) {
+                rval = {
+                    createAccount: await this.createAccount(cmd.createAccount.contact, cmd.createAccount.sendCode, cmd.createAccount.label, cmd.createAccount.tags),
+                };
+            }
+            else if (cmd.generateWebAuthnRegistrationChallengeForLoggedInUser) {
+                if (!ratchet_common_1.StringRatchet.trimToNull(loggedInUserId)) {
+                    ratchet_common_1.ErrorRatchet.throwFormattedErr('This requires a logged in user');
+                }
+                const tmp = await this.generateWebAuthnRegistrationChallengeForLoggedInUser(loggedInUserId, origin);
+                rval = { generateWebAuthnRegistrationChallengeForLoggedInUser: { dataAsJson: JSON.stringify(tmp) } };
+            }
+            else if (cmd.addContactToLoggedInUser) {
+                if (!ratchet_warden_common_1.WardenUtils.validContact(cmd.addContactToLoggedInUser)) {
+                    ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot add, invalid contact %j', cmd.addContactToLoggedInUser);
+                }
+                else {
+                    const out = await this.addContactMethodToUser(loggedInUserId, cmd.addContactToLoggedInUser);
+                    rval = { addContactToLoggedInUser: out };
+                }
+            }
+            else if (cmd.addWebAuthnRegistrationToLoggedInUser) {
+                if (!ratchet_common_1.StringRatchet.trimToNull(loggedInUserId)) {
+                    ratchet_common_1.ErrorRatchet.throwFormattedErr('This requires a logged in user');
+                }
+                const data = JSON.parse(cmd.addWebAuthnRegistrationToLoggedInUser.dataAsJson);
+                const out = await this.storeAuthnRegistration(loggedInUserId, origin, data);
+                if (out.updatedEntry) {
+                    rval = { addWebAuthnRegistrationToLoggedInUser: ratchet_warden_common_1.WardenUtils.stripWardenEntryToSummary(out.updatedEntry) };
+                }
+                else if (out.error) {
+                    rval = { error: out.error };
+                }
+                else {
+                    rval = { error: 'Cannot happen - neither user nor error set' };
+                }
+            }
+            else if (cmd.removeWebAuthnRegistration) {
+                const modified = await this.removeSingleWebAuthnRegistration(cmd.removeWebAuthnRegistration.userId, cmd.removeWebAuthnRegistration.credentialId);
+                rval = {
+                    removeWebAuthnRegistration: ratchet_warden_common_1.WardenUtils.stripWardenEntryToSummary(modified),
+                };
+            }
+            else if (cmd.removeWebAuthnRegistrationFromLoggedInUser) {
+                const modified = await this.removeSingleWebAuthnRegistration(loggedInUserId, cmd.removeWebAuthnRegistrationFromLoggedInUser);
+                rval = {
+                    removeWebAuthnRegistrationFromLoggedInUser: ratchet_warden_common_1.WardenUtils.stripWardenEntryToSummary(modified),
+                };
+            }
+            else if (cmd.removeContactFromLoggedInUser) {
+                const output = await this.removeContactMethodFromUser(loggedInUserId, cmd.removeContactFromLoggedInUser);
+                rval = {
+                    removeContactFromLoggedInUser: ratchet_warden_common_1.WardenUtils.stripWardenEntryToSummary(output),
+                };
+            }
+            else if (cmd.performLogin) {
+                const loginData = cmd.performLogin;
+                const loginOk = await this.processLogin(loginData, origin);
+                ratchet_common_1.Logger.info('Performing login - login auth check was : %s', loginOk);
+                if (loginOk) {
+                    const user = ratchet_common_1.StringRatchet.trimToNull(loginData.userId)
+                        ? await this.opts.storageProvider.findEntryById(loginData.userId)
+                        : await this.opts.storageProvider.findEntryByContact(loginData.contact);
+                    const decoration = await this.opts.userDecorationProvider.fetchDecoration(user);
+                    const wardenToken = {
+                        loginData: ratchet_warden_common_1.WardenUtils.stripWardenEntryToSummary(user),
+                        user: decoration.userTokenData,
+                        roles: ratchet_warden_common_1.WardenUtils.teamRolesToRoles(decoration.userTeamRoles),
+                        proxy: null,
+                    };
+                    const jwtToken = await this.opts.jwtRatchet.createTokenString(wardenToken, decoration.userTokenExpirationSeconds);
+                    const output = {
+                        request: loginData,
+                        userId: user.userId,
+                        jwtToken: jwtToken,
+                    };
+                    rval = { performLogin: output };
+                }
+                else {
+                    rval = { error: 'Login failed' };
+                }
+            }
+            else if (cmd.refreshJwtToken) {
+                const parsed = await this.opts.jwtRatchet.decodeToken(cmd.refreshJwtToken, ratchet_common_1.ExpiredJwtHandling.THROW_EXCEPTION);
+                const user = await this.opts.storageProvider.findEntryById(parsed.loginData.userId);
+                const decoration = await this.opts.userDecorationProvider.fetchDecoration(user);
+                const wardenToken = {
+                    loginData: ratchet_warden_common_1.WardenUtils.stripWardenEntryToSummary(user),
+                    user: decoration.userTokenData,
+                    roles: ratchet_warden_common_1.WardenUtils.teamRolesToRoles(decoration.userTeamRoles),
+                    proxy: null,
+                };
+                const newToken = await this.opts.jwtRatchet.createTokenString(wardenToken, decoration.userTokenExpirationSeconds);
+                rval = {
+                    refreshJwtToken: newToken,
+                };
+            }
+        }
+        else {
+            rval = { error: 'No command sent' };
+        }
+        return rval;
+    }
+    async createAccount(contact, sendCode, label, tags) {
+        var _a;
+        let rval = null;
+        if (ratchet_warden_common_1.WardenUtils.validContact(contact)) {
+            const old = await this.opts.storageProvider.findEntryByContact(contact);
+            if (!!old) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot create - account already exists for %j', contact);
+            }
+            const prov = this.senderForContact(contact);
+            if (!prov) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot create - no sending provider for type %s', contact.type);
+            }
+            const guid = ratchet_common_1.StringRatchet.createType4Guid();
+            const now = Date.now();
+            const newUser = {
+                userId: guid,
+                userLabel: label || 'User ' + guid,
+                contactMethods: [contact],
+                tags: tags || [],
+                webAuthnAuthenticators: [],
+                createdEpochMS: now,
+                updatedEpochMS: now,
+            };
+            const next = await this.opts.storageProvider.saveEntry(newUser);
+            rval = next.userId;
+            if ((_a = this === null || this === void 0 ? void 0 : this.opts) === null || _a === void 0 ? void 0 : _a.eventProcessor) {
+                await this.opts.eventProcessor.userCreated(next);
+            }
+            if (sendCode) {
+                ratchet_common_1.Logger.info('New user %j created and send requested - sending', next);
+                await this.sendExpiringValidationToken(contact);
+            }
+        }
+        else {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot create - invalid contact (missing or invalid fields)');
+        }
+        return rval;
+    }
+    async addContactMethodToUser(userId, contact) {
+        let rval = false;
+        if (ratchet_common_1.StringRatchet.trimToNull(userId) && ratchet_warden_common_1.WardenUtils.validContact(contact)) {
+            const otherUser = await this.opts.storageProvider.findEntryByContact(contact);
+            if (otherUser && otherUser.userId !== userId) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot add contact to this user, another user already has that contact');
+            }
+            const curUser = await this.opts.storageProvider.findEntryById(userId);
+            if (!curUser) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot add contact to this user, user does not exist');
+            }
+            curUser.contactMethods.push(contact);
+            await this.opts.storageProvider.saveEntry(curUser);
+            rval = true;
+        }
+        else {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot add - invalid config : %s %j', userId, contact);
+        }
+        return rval;
+    }
+    async removeContactMethodFromUser(userId, contact) {
+        let rval = null;
+        if (ratchet_common_1.StringRatchet.trimToNull(userId) && ratchet_warden_common_1.WardenUtils.validContact(contact)) {
+            const curUser = await this.opts.storageProvider.findEntryById(userId);
+            if (!curUser) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot remove contact from this user, user does not exist');
+            }
+            curUser.contactMethods = (curUser.contactMethods || []).filter((s) => s.type !== contact.type || s.value !== contact.value);
+            if (curUser.contactMethods.length === 0) {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot remove the last contact method from a user');
+            }
+            await this.opts.storageProvider.saveEntry(curUser);
+            rval = await this.opts.storageProvider.findEntryById(userId);
+        }
+        else {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot add - invalid config : %s %j', userId, contact);
+        }
+        return rval;
+    }
+    async generateWebAuthnRegistrationChallengeForLoggedInUser(userId, origin) {
+        if (!origin || !this.opts.allowedOrigins.includes(origin)) {
+            throw new Error('Invalid origin : ' + origin);
+        }
+        const asUrl = new URL(origin);
+        const rpID = asUrl.hostname;
+        const entry = await this.opts.storageProvider.findEntryById(userId);
+        const options = (0, server_1.generateRegistrationOptions)({
+            rpName: this.opts.relyingPartyName,
+            rpID: rpID,
+            userID: entry.userId,
+            userName: entry.userLabel,
+            attestationType: 'none',
+            excludeCredentials: entry.webAuthnAuthenticators.map((authenticator) => ({
+                id: ratchet_common_1.Base64Ratchet.base64StringToBuffer(authenticator.credentialPublicKeyBase64),
+                type: 'public-key',
+                transports: authenticator.transports,
+            })),
+        });
+        await this.opts.storageProvider.updateUserChallenge(entry.userId, rpID, options.challenge);
+        return options;
+    }
+    async storeAuthnRegistration(userId, origin, data) {
+        ratchet_common_1.Logger.info('Store authn data : %j', data);
+        let rval = null;
+        try {
+            if (!origin || !this.opts.allowedOrigins.includes(origin)) {
+                throw new Error('Invalid origin : ' + origin);
+            }
+            const asUrl = new URL(origin);
+            const rpID = asUrl.hostname;
+            const user = await this.opts.storageProvider.findEntryById(userId);
+            const expectedChallenge = await this.opts.storageProvider.fetchCurrentUserChallenge(user.userId, rpID);
+            const vrOpts = {
+                response: data,
+                expectedChallenge: expectedChallenge,
+                expectedOrigin: origin,
+                expectedRPID: rpID,
+            };
+            ratchet_common_1.Logger.info('Calling verifyRegistrationResponse: %j', vrOpts);
+            const verification = await (0, server_1.verifyRegistrationResponse)(vrOpts);
+            ratchet_common_1.Logger.info('verifyRegistrationResponse Result : %j', verification);
+            rval = {
+                updatedEntry: null,
+                registrationResponseId: data.id,
+                result: verification.verified ? ratchet_warden_common_1.WardenStoreRegistrationResponseType.Verified : ratchet_warden_common_1.WardenStoreRegistrationResponseType.Failed,
+            };
+            if (rval.result === ratchet_warden_common_1.WardenStoreRegistrationResponseType.Verified) {
+                ratchet_common_1.Logger.info('Storing registration');
+                const newAuth = {
+                    counter: verification.registrationInfo.counter,
+                    credentialBackedUp: verification.registrationInfo.credentialBackedUp,
+                    credentialDeviceType: verification.registrationInfo.credentialDeviceType,
+                    credentialIdBase64: data.id,
+                    credentialPublicKeyBase64: ratchet_common_1.Base64Ratchet.generateBase64VersionOfBuffer(Buffer.from(verification.registrationInfo.credentialPublicKey)),
+                };
+                user.webAuthnAuthenticators = (user.webAuthnAuthenticators || []).filter((wa) => wa.credentialIdBase64 !== newAuth.credentialIdBase64);
+                user.webAuthnAuthenticators.push(newAuth);
+                const storedUser = await this.opts.storageProvider.saveEntry(user);
+                rval.updatedEntry = storedUser;
+                ratchet_common_1.Logger.info('Stored auth : %j', storedUser);
+            }
+        }
+        catch (err) {
+            rval = {
+                registrationResponseId: data.id,
+                result: ratchet_warden_common_1.WardenStoreRegistrationResponseType.Error,
+                error: ratchet_common_1.ErrorRatchet.safeStringifyErr(err),
+            };
+        }
+        return rval;
+    }
+    async generateWebAuthnAuthenticationChallengeForUserId(userId, origin) {
+        const user = await this.opts.storageProvider.findEntryById(userId);
+        const rval = await this.generateWebAuthnAuthenticationChallenge(user, origin);
+        return rval;
+    }
+    async generateWebAuthnAuthenticationChallenge(user, origin) {
+        const userAuthenticators = user.webAuthnAuthenticators;
+        if (!origin || !this.opts.allowedOrigins.includes(origin)) {
+            throw new Error('Invalid origin : ' + origin);
+        }
+        const asUrl = new URL(origin);
+        const rpID = asUrl.hostname;
+        const out = userAuthenticators.map((authenticator) => {
+            const next = {
+                id: Buffer.from(authenticator.credentialIdBase64, 'base64'),
+                type: 'public-key',
+                transports: authenticator.transports,
+            };
+            return next;
+        });
+        const options = (0, server_1.generateAuthenticationOptions)({
+            allowCredentials: out,
+            userVerification: 'preferred',
+        });
+        await this.opts.storageProvider.updateUserChallenge(user.userId, rpID, options.challenge);
+        return options;
+    }
+    senderForContact(contact) {
+        let rval = null;
+        if (contact === null || contact === void 0 ? void 0 : contact.type) {
+            rval = (this.opts.messageSendingProviders || []).find((p) => p.handlesContactType(contact.type));
+        }
+        return rval;
+    }
+    async sendExpiringValidationToken(request) {
+        let rval = false;
+        if ((request === null || request === void 0 ? void 0 : request.type) && ratchet_common_1.StringRatchet.trimToNull(request === null || request === void 0 ? void 0 : request.value)) {
+            const prov = this.senderForContact(request);
+            if (prov) {
+                const token = await this.expiringCodeRatchet.createNewCode({
+                    context: request.value,
+                    length: 6,
+                    alphabet: '0123456789',
+                    timeToLiveSeconds: 300,
+                    tags: ['Login'],
+                });
+                const msg = await prov.formatMessage(request, ratchet_warden_common_1.WardenCustomerMessageType.ExpiringCode, {
+                    code: token.code,
+                    relyingPartyName: this.opts.relyingPartyName,
+                });
+                rval = await prov.sendMessage(request, msg);
+            }
+            else {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('No provider found for contact type %s', request.type);
+            }
+        }
+        else {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot send - invalid request %j', request);
+        }
+        return rval;
+    }
+    async processLogin(request, origin) {
+        ratchet_common_1.Logger.info('Processing login : %s : %j', origin, request);
+        let rval = false;
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(request, 'request');
+        ratchet_common_1.RequireRatchet.true(!!ratchet_common_1.StringRatchet.trimToNull(request === null || request === void 0 ? void 0 : request.userId) || ratchet_warden_common_1.WardenUtils.validContact(request === null || request === void 0 ? void 0 : request.contact), 'Invalid contact and no userId');
+        ratchet_common_1.RequireRatchet.true(!!(request === null || request === void 0 ? void 0 : request.webAuthn) || !!ratchet_common_1.StringRatchet.trimToNull(request === null || request === void 0 ? void 0 : request.expiringToken), 'You must provide one of webAuthn or expiringToken');
+        ratchet_common_1.RequireRatchet.true(!(request === null || request === void 0 ? void 0 : request.webAuthn) || !ratchet_common_1.StringRatchet.trimToNull(request === null || request === void 0 ? void 0 : request.expiringToken), 'WebAuthn and ExpiringToken may not BOTH be set');
+        const user = ratchet_common_1.StringRatchet.trimToNull(request === null || request === void 0 ? void 0 : request.userId)
+            ? await this.opts.storageProvider.findEntryById(request === null || request === void 0 ? void 0 : request.userId)
+            : await this.opts.storageProvider.findEntryByContact(request.contact);
+        if (!user) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('No user found for %j / %s', request === null || request === void 0 ? void 0 : request.contact, request === null || request === void 0 ? void 0 : request.userId);
+        }
+        if (request.webAuthn) {
+            rval = await this.loginWithWebAuthnRequest(user, origin, request.webAuthn);
+        }
+        else if (ratchet_common_1.StringRatchet.trimToNull(request.expiringToken)) {
+            const lookup = await this.expiringCodeRatchet.checkCode(ratchet_common_1.StringRatchet.trimToEmpty(request.expiringToken), ratchet_common_1.StringRatchet.trimToEmpty(request.contact.value), true);
+            if (lookup) {
+                rval = true;
+            }
+            else {
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Cannot login - token is invalid for this user');
+            }
+        }
+        return rval;
+    }
+    async loginWithWebAuthnRequest(user, origin, data) {
+        let rval = false;
+        const asUrl = new URL(origin);
+        const rpID = asUrl.hostname;
+        const expectedChallenge = await this.opts.storageProvider.fetchCurrentUserChallenge(user.userId, rpID);
+        const auth = (user.webAuthnAuthenticators || []).find((s) => s.credentialIdBase64 === data.id);
+        if (!auth) {
+            throw new Error(`Could not find authenticator ${data.id} for user ${user.userId}`);
+        }
+        const authenticator = {
+            counter: auth.counter,
+            credentialID: ratchet_common_1.Base64Ratchet.base64StringToBuffer(auth.credentialIdBase64),
+            credentialPublicKey: ratchet_common_1.Base64Ratchet.base64StringToBuffer(auth.credentialPublicKeyBase64),
+        };
+        const vrOpts = {
+            response: data,
+            expectedChallenge,
+            expectedOrigin: origin,
+            expectedRPID: rpID,
+            authenticator,
+        };
+        const verification = await (0, server_1.verifyAuthenticationResponse)(vrOpts);
+        if (verification.verified) {
+            rval = true;
+        }
+        return rval;
+    }
+    async removeSingleWebAuthnRegistration(userId, key) {
+        let ent = await this.opts.storageProvider.findEntryById(userId);
+        if (ent) {
+            ent.webAuthnAuthenticators = (ent.webAuthnAuthenticators || []).filter((s) => s.credentialIdBase64 !== key);
+            ent = await this.opts.storageProvider.saveEntry(ent);
+        }
+        else {
+            ratchet_common_1.Logger.info('Not removing - no such user as %s', userId);
+        }
+        return ent;
+    }
+    async removeUser(userId) {
+        var _a;
+        let rval = false;
+        if (ratchet_common_1.StringRatchet.trimToNull(userId)) {
+            const oldUser = await this.opts.storageProvider.findEntryById(userId);
+            if (oldUser) {
+                await this.opts.storageProvider.removeEntry(userId);
+                if ((_a = this === null || this === void 0 ? void 0 : this.opts) === null || _a === void 0 ? void 0 : _a.eventProcessor) {
+                    await this.opts.eventProcessor.userRemoved(oldUser);
+                }
+                rval = true;
+            }
+            else {
+                ratchet_common_1.Logger.warn('Cannot remove non-existent user : %s', userId);
+            }
+        }
+        return rval;
+    }
+}
+exports.WardenService = WardenService;

package/dist/es/build/ratchet-warden-server-info.js

@@ -0,0 +1,14 @@
+export class RatchetWardenServerInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '84',
+            hash: 'f4d435f9dba4b8b2eaefb31582fcf44290522d7f',
+            branch: 'alpha-2023-03-12-7',
+            tag: 'alpha-2023-03-12-7',
+            timeBuiltISO: '2023-03-12T22:04:40-0700',
+            notes: '',
+        };
+        return val;
+    }
+}

package/dist/es/index.js

@@ -0,0 +1,15 @@
+export * from './build/ratchet-warden-server-info';
+export * from './server/warden-service-options';
+export * from './server/warden-service';
+export * from './server/provider/warden-default-user-decoration-provider';
+export * from './server/provider/warden-event-processing-provider';
+export * from './server/provider/warden-mailer-message-sending-provider-options';
+export * from './server/provider/warden-mailer-message-sending-provider';
+export * from './server/provider/warden-message-sending-provider';
+export * from './server/provider/warden-no-op-event-processing-provider';
+export * from './server/provider/warden-s3-single-file-storage-provider-options';
+export * from './server/provider/warden-s3-single-file-storage-provider';
+export * from './server/provider/warden-storage-provider';
+export * from './server/provider/warden-twilio-text-message-sending-provider-options';
+export * from './server/provider/warden-twilio-text-message-sending-provider';
+export * from './server/provider/warden-user-decoration-provider';

package/dist/es/server/provider/warden-default-user-decoration-provider.js

@@ -0,0 +1,11 @@
+import { WardenUtils } from '@bitblit/ratchet-warden-common';
+export class WardenDefaultUserDecorationProvider {
+    async fetchDecoration(wardenUser) {
+        const rval = {
+            userTokenData: WardenUtils.stripWardenEntryToSummary(wardenUser),
+            userTokenExpirationSeconds: 3600,
+            userTeamRoles: [{ team: 'WARDEN', role: 'USER' }],
+        };
+        return rval;
+    }
+}

package/dist/es/server/provider/warden-event-processing-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/es/server/provider/warden-mailer-message-sending-provider-options.js

@@ -0,0 +1 @@
+export {};

package/dist/es/server/provider/warden-mailer-message-sending-provider.js

@@ -0,0 +1,32 @@
+import { WardenContactType } from '@bitblit/ratchet-warden-common';
+import { Logger } from '@bitblit/ratchet-common';
+export class WardenMailerMessageSendingProvider {
+    static defaultOptions() {
+        const rval = {
+            emailBaseLayoutName: undefined,
+            expiringTokenHtmlTemplateName: 'expiring-token-request-email',
+            expiringTokenTxtTemplateName: undefined,
+        };
+        return rval;
+    }
+    constructor(mailer, options = WardenMailerMessageSendingProvider.defaultOptions()) {
+        this.mailer = mailer;
+        this.options = options;
+    }
+    async formatMessage(contact, messageType, context) {
+        const rts = {
+            destinationAddresses: [contact.value],
+            subject: 'Your login token',
+        };
+        await this.mailer.fillEmailBody(rts, context, this.options.expiringTokenHtmlTemplateName, this.options.expiringTokenTxtTemplateName, this.options.emailBaseLayoutName);
+        return rts;
+    }
+    handlesContactType(type) {
+        return type === WardenContactType.EmailAddress;
+    }
+    async sendMessage(contact, message) {
+        const rval = await this.mailer.sendEmail(message);
+        Logger.debug('SendRawEmailResponse was : %j', rval);
+        return !!rval;
+    }
+}

package/dist/es/server/provider/warden-message-sending-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/es/server/provider/warden-no-op-event-processing-provider.js

@@ -0,0 +1,4 @@
+export class WardenNoOpEventProcessingProvider {
+    async userCreated(entry) { }
+    async userRemoved(entry) { }
+}

package/dist/es/server/provider/warden-s3-single-file-storage-provider-options.js

@@ -0,0 +1 @@
+export {};

package/dist/es/server/provider/warden-s3-single-file-storage-provider.js

@@ -0,0 +1,86 @@
+import { WardenUtils } from '@bitblit/ratchet-warden-common';
+import { S3CacheRatchet } from '@bitblit/ratchet-aws';
+import { ErrorRatchet, StringRatchet } from '@bitblit/ratchet-common';
+export class WardenS3SingleFileStorageProvider {
+    constructor(s3, options) {
+        this.s3 = s3;
+        this.options = options;
+        this.ratchet = new S3CacheRatchet(this.s3, this.options.bucket);
+    }
+    async listUserSummaries() {
+        const allData = (await this.fetchDataFile()).entries;
+        const rval = allData.map((d) => WardenUtils.stripWardenEntryToSummary(d));
+        return rval;
+    }
+    async fetchDataFile() {
+        let data = await this.ratchet.fetchCacheFileAsObject(this.options.dataFileKey);
+        data = data || {
+            entries: [],
+            challenges: [],
+        };
+        return data;
+    }
+    async storeDataFile(file) {
+        let rval = null;
+        if (file) {
+            rval = await this.ratchet.writeObjectToCacheFile(this.options.dataFileKey, file);
+        }
+        return rval;
+    }
+    async fetchCurrentUserChallenge(userId, relyingPartyId) {
+        const data = await this.fetchDataFile();
+        const entry = (data.challenges || []).find((d) => d.userId === userId && d.relyingPartyId === relyingPartyId);
+        if (!entry) {
+            ErrorRatchet.throwFormattedErr('fetchCurrentUserChallenge: Could not find user %s', userId);
+        }
+        return entry.challenge;
+    }
+    async findEntryByContact(contact) {
+        let rval = null;
+        if (contact?.type && StringRatchet.trimToNull(contact?.value)) {
+            const data = await this.fetchDataFile();
+            rval = (data.entries || []).find((d) => !!(d.contactMethods || []).find((x) => x.type === contact.type && x.value === contact.value));
+        }
+        return rval;
+    }
+    async findEntryById(userId) {
+        let rval = null;
+        if (StringRatchet.trimToNull(userId)) {
+            const data = await this.fetchDataFile();
+            rval = (data.entries || []).find((d) => d.userId === userId);
+        }
+        return rval;
+    }
+    async removeEntry(userId) {
+        const data = await this.fetchDataFile();
+        data.entries = (data.entries || []).filter((d) => d.userId !== userId);
+        await this.storeDataFile(data);
+        return true;
+    }
+    async saveEntry(entry) {
+        let rval = null;
+        if (entry && entry.userId) {
+            const now = Date.now();
+            entry.createdEpochMS = entry.createdEpochMS || now;
+            entry.updatedEpochMS = now;
+            const data = await this.fetchDataFile();
+            data.entries = (data.entries || []).filter((d) => d.userId !== entry.userId);
+            data.entries.push(entry);
+            await this.storeDataFile(data);
+            rval = await this.findEntryById(entry.userId);
+        }
+        return rval;
+    }
+    async updateUserChallenge(userId, relyingPartyId, challenge) {
+        const data = await this.fetchDataFile();
+        data.challenges = (data.challenges || []).filter((d) => d.userId !== userId || d.relyingPartyId !== relyingPartyId);
+        data.challenges.push({
+            userId: userId,
+            relyingPartyId: relyingPartyId,
+            challenge: challenge,
+            updatedEpochMS: Date.now(),
+        });
+        await this.storeDataFile(data);
+        return true;
+    }
+}

package/dist/es/server/provider/warden-storage-provider.js

@@ -0,0 +1 @@
+export {};

package/dist/es/server/provider/warden-twilio-text-message-sending-provider-options.js

@@ -0,0 +1 @@
+export {};