@restorecommerce/facade 1.1.6 → 1.3.0

package/dist/modules/identity/oauth/oauth.js

@@ -1,92 +1,142 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readFile } from 'node:fs';
+import path, { resolve as resolvePath } from 'node:path';
+import hbs from 'handlebars';
+import { marshallProtobufAny } from '../oidc/utils.js';
+import * as uuid from 'uuid';
+import { RegisterRequest, UserType } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/user.js';
+import * as jose from 'jose';
+import * as url from 'node:url';
+import Router from 'koa-router';
+import { koaBody as bodyParser } from 'koa-body';
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+const upsertUserToken = (ids, accountId) => __awaiter(void 0, void 0, void 0, function* () {
+    const token = new jose.UnsecuredJWT({})
+        .setIssuedAt()
+        .setExpirationTime('30d')
+        .encode();
+    // 1 Month
+    const expiresIn = Date.now() + (1000 * 60 * 60 * 24 * 30);
+    yield ids.token.upsert({
+        id: uuid.v4().replace(/-/g, ''),
+        type: 'access_token',
+        expiresIn,
+        payload: marshallProtobufAny({
+            accountId,
+            exp: expiresIn,
+            jti: token
+        })
+    });
+    return token;
+});
+let layoutHbs;
+export const layout = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!layoutHbs) {
+        const layoutTpl = yield new Promise((resolve, reject) => {
+            readFile(resolvePath(__dirname, 'views/layout.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
+        });
+        layoutHbs = hbs.compile(layoutTpl);
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+    return layoutHbs(context);
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.account = exports.login = exports.register = exports.layout = exports.createOAuth = void 0;
-const fs_1 = require("fs");
-const path_1 = require("path");
-const handlebars_1 = __importDefault(require("handlebars"));
-const utils_1 = require("../oidc/utils");
-const uuid = __importStar(require("uuid"));
-const user_1 = require("@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/user");
-const jose = __importStar(require("jose"));
-const Router = eval('require("koa-router")');
-const bodyParser = eval('require("koa-body")');
-const createOAuth = () => {
+let registerHbs;
+export const register = (email) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!registerHbs) {
+        const registerTpl = yield new Promise((resolve, reject) => {
+            readFile(resolvePath(__dirname, 'views/register.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
+        });
+        registerHbs = hbs.compile(registerTpl);
+    }
+    return layout({
+        title: 'Register',
+        body: registerHbs({ email })
+    });
+});
+let loginHbs;
+export const login = (links) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!loginHbs) {
+        const loginTpl = yield new Promise((resolve, reject) => {
+            readFile(resolvePath(__dirname, 'views/login.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
+        });
+        loginHbs = hbs.compile(loginTpl);
+    }
+    return layout({
+        title: 'Login',
+        body: loginHbs({ links })
+    });
+});
+let accountHbs;
+export const account = (user) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!accountHbs) {
+        const accountTpl = yield new Promise((resolve, reject) => {
+            readFile(resolvePath(__dirname, 'views/account.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
+        });
+        accountHbs = hbs.compile(accountTpl);
+    }
+    return layout({
+        title: 'Account',
+        body: accountHbs({ user })
+    });
+});
+export const createOAuth = () => {
     const router = new Router();
     router.use(bodyParser({ multipart: true }));
-    router.get('/oauth2-login', async (ctx, next) => {
+    router.get('/oauth2-login', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         ctx.type = 'html';
-        ctx.body = await (0, exports.login)((await ctx.identitySrvClient.oauth.GenerateLinks({})).links);
+        ctx.body = yield login((yield ctx.identitySrvClient.oauth.GenerateLinks({})).links);
         return next();
-    });
-    router.get('/oauth2-logout', async (ctx, next) => {
+    }));
+    router.get('/oauth2-logout', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         ctx.cookies.set('token', undefined);
         ctx.status = 303;
         ctx.redirect('/oauth2-login');
         ctx.body = 'Redirecting to login page';
         return next();
-    });
-    router.get('/oauth2-urls', async (ctx, next) => {
-        ctx.body = (await ctx.identitySrvClient.oauth.GenerateLinks({})).links;
+    }));
+    router.get('/oauth2-urls', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.body = (yield ctx.identitySrvClient.oauth.GenerateLinks({})).links;
         return next();
-    });
-    router.get('/oauth2-account', async (ctx, next) => {
+    }));
+    router.get('/oauth2-account', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         const token = ctx.cookies.get('token');
         if (!token) {
             ctx.body = 'user not logged in';
             return next();
         }
         const ids = ctx.identitySrvClient;
-        const user = await ids.user.findByToken({
-            token: token
+        const user = yield ids.user.findByToken({
+            token
         });
         if (!user || !user.payload) {
             ctx.body = 'user not logged in';
             return next();
         }
         ctx.type = 'html';
-        ctx.body = await (0, exports.account)(user.payload);
+        ctx.body = yield account(user.payload);
         return next();
-    });
-    router.post('/oauth2-register', async (ctx, next) => {
+    }));
+    router.post('/oauth2-register', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         const ids = ctx.identitySrvClient;
         const body = ctx.request.body;
-        const user = await ids.user.register(user_1.RegisterRequest.fromPartial({
+        const user = yield ids.user.register(RegisterRequest.fromPartial({
             email: body.email,
             name: body.username,
             firstName: body.first_name,
             lastName: body.last_name,
             password: body.password,
-            userType: user_1.UserType.INDIVIDUAL_USER,
+            userType: UserType.INDIVIDUAL_USER,
             guest: false,
         }));
         if (user.payload) {
-            const token = await upsertUserToken(ids, user.payload.id);
+            const token = yield upsertUserToken(ids, user.payload.id);
             ctx.cookies.set('token', token);
             ctx.status = 303;
             ctx.redirect('/oauth2-account');
@@ -97,17 +147,17 @@ const createOAuth = () => {
             ctx.body = user.status.message;
         }
         return next();
-    });
-    router.get('/oauth2/:service', async (ctx, next) => {
+    }));
+    router.get('/oauth2/:service', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         const ids = ctx.identitySrvClient;
-        const user = await ids.oauth.exchangeCode({
+        const user = yield ids.oauth.exchangeCode({
             service: ctx.params.service,
             code: ctx.request.query['code'],
             state: ctx.request.query['state']
         });
         if (!user.user || !user.user.payload || !user.token || (user.user.status && user.user.status.code !== 200)) {
             ctx.type = 'html';
-            ctx.body = await (0, exports.register)(user.email || '');
+            ctx.body = yield register(user.email || '');
             return next();
         }
         ctx.cookies.set('token', user.token.token);
@@ -115,79 +165,6 @@ const createOAuth = () => {
         ctx.redirect('/oauth2-account');
         ctx.body = 'Redirecting to account page';
         return next();
-    });
+    }));
     return router;
 };
-exports.createOAuth = createOAuth;
-const upsertUserToken = async (ids, accountId) => {
-    const token = new jose.UnsecuredJWT({})
-        .setIssuedAt()
-        .setExpirationTime('30d')
-        .encode();
-    // 1 Month
-    const expiresIn = Date.now() + (1000 * 60 * 60 * 24 * 30);
-    await ids.token.upsert({
-        id: uuid.v4().replace(/-/g, ''),
-        type: 'access_token',
-        expiresIn: expiresIn,
-        payload: (0, utils_1.marshallProtobufAny)({
-            accountId: accountId,
-            exp: expiresIn,
-            jti: token
-        })
-    });
-    return token;
-};
-let layoutHbs;
-const layout = async (context) => {
-    if (!layoutHbs) {
-        const layoutTpl = await new Promise((resolve, reject) => {
-            (0, fs_1.readFile)((0, path_1.resolve)(__dirname, 'views/layout.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
-        });
-        layoutHbs = handlebars_1.default.compile(layoutTpl);
-    }
-    return layoutHbs(context);
-};
-exports.layout = layout;
-let registerHbs;
-const register = async (email) => {
-    if (!registerHbs) {
-        const registerTpl = await new Promise((resolve, reject) => {
-            (0, fs_1.readFile)((0, path_1.resolve)(__dirname, 'views/register.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
-        });
-        registerHbs = handlebars_1.default.compile(registerTpl);
-    }
-    return (0, exports.layout)({
-        title: 'Register',
-        body: registerHbs({ email })
-    });
-};
-exports.register = register;
-let loginHbs;
-const login = async (links) => {
-    if (!loginHbs) {
-        const loginTpl = await new Promise((resolve, reject) => {
-            (0, fs_1.readFile)((0, path_1.resolve)(__dirname, 'views/login.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
-        });
-        loginHbs = handlebars_1.default.compile(loginTpl);
-    }
-    return (0, exports.layout)({
-        title: 'Login',
-        body: loginHbs({ links })
-    });
-};
-exports.login = login;
-let accountHbs;
-const account = async (user) => {
-    if (!accountHbs) {
-        const accountTpl = await new Promise((resolve, reject) => {
-            (0, fs_1.readFile)((0, path_1.resolve)(__dirname, 'views/account.hbs'), (err, data) => err ? reject(err) : resolve(data.toString()));
-        });
-        accountHbs = handlebars_1.default.compile(accountTpl);
-    }
-    return (0, exports.layout)({
-        title: 'Account',
-        body: accountHbs({ user })
-    });
-};
-exports.account = account;

package/dist/modules/identity/oidc/adapter.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from 'winston';
-import { Adapter, AdapterConstructor } from 'oidc-provider';
-import { TokenServiceClient as tokenService } from "@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/token";
+import { type Logger } from 'winston';
+import { type Adapter, type AdapterConstructor } from 'oidc-provider';
+import { type TokenServiceClient as tokenService } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/token.js';
 export declare function createIdentityServiceAdapterClass(remoteTokenService: tokenService, logger: Logger, localTokenServiceFactory?: (type: string) => Adapter): AdapterConstructor;

package/dist/modules/identity/oidc/adapter.js

@@ -1,116 +1,135 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIdentityServiceAdapterClass = void 0;
-const utils_1 = require("./utils");
-const auth_1 = require("@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/auth");
-const in_memory_adapter_1 = require("./in-memory-adapter");
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { marshallProtobufAny, unmarshallProtobufAny } from './utils.js';
+import { Subject } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/auth.js';
+import { InMemoryAdapter } from './in-memory-adapter.js';
 const delegateToRemoteService = (type) => ['AccessToken', 'RefreshToken'].includes(type);
-function createIdentityServiceAdapterClass(remoteTokenService, logger, localTokenServiceFactory) {
+export function createIdentityServiceAdapterClass(remoteTokenService, logger, localTokenServiceFactory) {
     return class IdentityServiceAdapter {
         constructor(type) {
             this.type = type;
-            this.localTokenService = localTokenServiceFactory ? localTokenServiceFactory(type) : new in_memory_adapter_1.InMemoryAdapter(type);
+            this.localTokenService = localTokenServiceFactory ? localTokenServiceFactory(type) : new InMemoryAdapter(type);
         }
-        async consume(id) {
-            logger.verbose(`Consuming ${this.type} token ${id}`);
-            if (delegateToRemoteService(this.type)) {
-                try {
-                    await remoteTokenService.consume({
-                        id,
-                        type: this.type,
-                        subject: undefined
-                    });
+        consume(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logger.verbose(`Consuming ${this.type} token ${id}`);
+                if (delegateToRemoteService(this.type)) {
+                    try {
+                        yield remoteTokenService.consume({
+                            id,
+                            type: this.type,
+                            subject: undefined
+                        });
+                    }
+                    catch (error) {
+                        logger.error(`Error consuming ${this.type} token ${id}`, error);
+                    }
                 }
-                catch (error) {
-                    logger.error(`Error consuming ${this.type} token ${id}`, error);
+                else {
+                    yield this.localTokenService.consume(id);
                 }
-            }
-            else {
-                await this.localTokenService.consume(id);
-            }
+            });
         }
-        async destroy(id) {
-            logger.verbose(`Destroying ${this.type} token ${id}`);
-            if (delegateToRemoteService(this.type)) {
-                try {
-                    await remoteTokenService.destroy({
-                        id,
-                        type: this.type,
-                        subject: auth_1.Subject.fromPartial({ token: id })
-                    });
+        destroy(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logger.verbose(`Destroying ${this.type} token ${id}`);
+                if (delegateToRemoteService(this.type)) {
+                    try {
+                        yield remoteTokenService.destroy({
+                            id,
+                            type: this.type,
+                            subject: Subject.fromPartial({ token: id })
+                        });
+                    }
+                    catch (error) {
+                        logger.error(`Error destroying ${this.type} token ${id}`, error);
+                    }
                 }
-                catch (error) {
-                    logger.error(`Error destroying ${this.type} token ${id}`, error);
+                else {
+                    yield this.localTokenService.destroy(id);
                 }
-            }
-            else {
-                await this.localTokenService.destroy(id);
-            }
+            });
         }
-        async find(id) {
-            logger.verbose(`Finding ${this.type} token ${id}`);
-            if (delegateToRemoteService(this.type)) {
-                try {
-                    let result = await remoteTokenService.find({
-                        id,
-                        type: this.type,
-                        subject: auth_1.Subject.fromPartial({ token: id })
-                    });
-                    return result ? (0, utils_1.unmarshallProtobufAny)(result) : undefined;
+        find(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logger.verbose(`Finding ${this.type} token ${id}`);
+                if (delegateToRemoteService(this.type)) {
+                    try {
+                        let result = yield remoteTokenService.find({
+                            id,
+                            type: this.type,
+                            subject: Subject.fromPartial({ token: id })
+                        });
+                        return result ? unmarshallProtobufAny(result) : undefined;
+                    }
+                    catch (error) {
+                        logger.error(`Error finding ${this.type} token ${id}`, error);
+                        return undefined;
+                    }
                 }
-                catch (error) {
-                    logger.error(`Error finding ${this.type} token ${id}`, error);
-                    return undefined;
+                else {
+                    return yield this.localTokenService.find(id);
                 }
-            }
-            else {
-                return await this.localTokenService.find(id);
-            }
+            });
         }
-        async findByUid(uid) {
-            logger.verbose(`Finding by Uid ${uid}`);
-            return await this.localTokenService.findByUid(uid);
+        findByUid(uid) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logger.verbose(`Finding by Uid ${uid}`);
+                return yield this.localTokenService.findByUid(uid);
+            });
         }
         // Not needed. DeviceFlow only
-        async findByUserCode(userCode) {
-            logger.error('Finding br UserCode is unsupported', this.type, ...arguments);
-            throw new Error('UNSUPPORTED');
+        findByUserCode(userCode) {
+            return __awaiter(this, arguments, void 0, function* () {
+                logger.error('Finding br UserCode is unsupported', this.type, ...arguments);
+                throw new Error('UNSUPPORTED');
+            });
         }
-        async upsert(id, payload, expiresIn) {
-            logger.error(`Upserting ${this.type} token ${id}`, payload);
-            if (delegateToRemoteService(this.type)) {
-                try {
-                    await remoteTokenService.upsert({
-                        expiresIn,
-                        id,
-                        payload: (0, utils_1.marshallProtobufAny)(payload),
-                        type: this.type,
-                        subject: undefined
-                    });
+        upsert(id, payload, expiresIn) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logger.error(`Upserting ${this.type} token ${id}`, payload);
+                if (delegateToRemoteService(this.type)) {
+                    try {
+                        yield remoteTokenService.upsert({
+                            expiresIn,
+                            id,
+                            payload: marshallProtobufAny(payload),
+                            type: this.type,
+                            subject: undefined
+                        });
+                    }
+                    catch (error) {
+                        logger.error(`Error upserting ${this.type} token ${id}`, error);
+                    }
                 }
-                catch (error) {
-                    logger.error(`Error upserting ${this.type} token ${id}`, error);
+                else {
+                    return this.localTokenService.upsert(id, payload, expiresIn * 1000);
                 }
-            }
-            else {
-                return this.localTokenService.upsert(id, payload, expiresIn * 1000);
-            }
+            });
         }
-        async revokeByGrantId(grantId) {
-            logger.error(`Revoking grant id ${this.type} token ${grantId}`);
-            await this.localTokenService.revokeByGrantId(grantId);
-            if (delegateToRemoteService(this.type)) {
-                try {
-                    await remoteTokenService.revokeByGrantId({
-                        grantId,
-                        subject: auth_1.Subject.fromPartial({ token: grantId })
-                    });
+        revokeByGrantId(grantId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logger.error(`Revoking grant id ${this.type} token ${grantId}`);
+                yield this.localTokenService.revokeByGrantId(grantId);
+                if (delegateToRemoteService(this.type)) {
+                    try {
+                        yield remoteTokenService.revokeByGrantId({
+                            grantId,
+                            subject: Subject.fromPartial({ token: grantId })
+                        });
+                    }
+                    catch (error) {
+                        logger.error(`Error revoking grant id ${grantId}`, error);
+                    }
                 }
-                catch (error) {
-                    logger.error(`Error revoking grant id ${grantId}`, error);
-                }
-            }
+            });
         }
     };
 }
-exports.createIdentityServiceAdapterClass = createIdentityServiceAdapterClass;

package/dist/modules/identity/oidc/in-memory-adapter.d.ts

@@ -1,4 +1,4 @@
-import { Adapter, AdapterPayload } from 'oidc-provider';
+import { type Adapter, type AdapterPayload } from 'oidc-provider';
 export declare class InMemoryAdapter implements Adapter {
     private type;
     constructor(type: string);