@restorecommerce/facade 1.3.8 → 1.3.10

package/dist/modules/identity/gql/schema.generated.js

@@ -0,0 +1,75 @@
+export var IoRestorecommerceUserUserType;
+(function (IoRestorecommerceUserUserType) {
+    IoRestorecommerceUserUserType[IoRestorecommerceUserUserType["OrgUser"] = 0] = "OrgUser";
+    IoRestorecommerceUserUserType[IoRestorecommerceUserUserType["IndividualUser"] = 1] = "IndividualUser";
+    IoRestorecommerceUserUserType[IoRestorecommerceUserUserType["Guest"] = 2] = "Guest";
+    IoRestorecommerceUserUserType[IoRestorecommerceUserUserType["TechnicalUser"] = 3] = "TechnicalUser";
+})(IoRestorecommerceUserUserType || (IoRestorecommerceUserUserType = {}));
+export var IoRestorecommerceResourcebaseSortSortOrder;
+(function (IoRestorecommerceResourcebaseSortSortOrder) {
+    IoRestorecommerceResourcebaseSortSortOrder[IoRestorecommerceResourcebaseSortSortOrder["Unsorted"] = 0] = "Unsorted";
+    IoRestorecommerceResourcebaseSortSortOrder[IoRestorecommerceResourcebaseSortSortOrder["Ascending"] = 1] = "Ascending";
+    IoRestorecommerceResourcebaseSortSortOrder[IoRestorecommerceResourcebaseSortSortOrder["Descending"] = 2] = "Descending";
+})(IoRestorecommerceResourcebaseSortSortOrder || (IoRestorecommerceResourcebaseSortSortOrder = {}));
+export var IoRestorecommerceResourcebaseFilterOperation;
+(function (IoRestorecommerceResourcebaseFilterOperation) {
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["Eq"] = 0] = "Eq";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["Lt"] = 1] = "Lt";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["Lte"] = 2] = "Lte";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["Gt"] = 3] = "Gt";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["Gte"] = 4] = "Gte";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["IsEmpty"] = 5] = "IsEmpty";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["ILike"] = 6] = "ILike";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["In"] = 7] = "In";
+    IoRestorecommerceResourcebaseFilterOperation[IoRestorecommerceResourcebaseFilterOperation["Neq"] = 8] = "Neq";
+})(IoRestorecommerceResourcebaseFilterOperation || (IoRestorecommerceResourcebaseFilterOperation = {}));
+export var IoRestorecommerceResourcebaseFilterValueType;
+(function (IoRestorecommerceResourcebaseFilterValueType) {
+    IoRestorecommerceResourcebaseFilterValueType[IoRestorecommerceResourcebaseFilterValueType["String"] = 0] = "String";
+    IoRestorecommerceResourcebaseFilterValueType[IoRestorecommerceResourcebaseFilterValueType["Number"] = 1] = "Number";
+    IoRestorecommerceResourcebaseFilterValueType[IoRestorecommerceResourcebaseFilterValueType["Boolean"] = 2] = "Boolean";
+    IoRestorecommerceResourcebaseFilterValueType[IoRestorecommerceResourcebaseFilterValueType["Date"] = 3] = "Date";
+    IoRestorecommerceResourcebaseFilterValueType[IoRestorecommerceResourcebaseFilterValueType["Array"] = 4] = "Array";
+})(IoRestorecommerceResourcebaseFilterValueType || (IoRestorecommerceResourcebaseFilterValueType = {}));
+export var IoRestorecommerceFilterFilterOperation;
+(function (IoRestorecommerceFilterFilterOperation) {
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["Eq"] = 0] = "Eq";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["Lt"] = 1] = "Lt";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["Lte"] = 2] = "Lte";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["Gt"] = 3] = "Gt";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["Gte"] = 4] = "Gte";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["IsEmpty"] = 5] = "IsEmpty";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["ILike"] = 6] = "ILike";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["In"] = 7] = "In";
+    IoRestorecommerceFilterFilterOperation[IoRestorecommerceFilterFilterOperation["Neq"] = 8] = "Neq";
+})(IoRestorecommerceFilterFilterOperation || (IoRestorecommerceFilterFilterOperation = {}));
+export var IoRestorecommerceFilterFilterValueType;
+(function (IoRestorecommerceFilterFilterValueType) {
+    IoRestorecommerceFilterFilterValueType[IoRestorecommerceFilterFilterValueType["String"] = 0] = "String";
+    IoRestorecommerceFilterFilterValueType[IoRestorecommerceFilterFilterValueType["Number"] = 1] = "Number";
+    IoRestorecommerceFilterFilterValueType[IoRestorecommerceFilterFilterValueType["Boolean"] = 2] = "Boolean";
+    IoRestorecommerceFilterFilterValueType[IoRestorecommerceFilterFilterValueType["Date"] = 3] = "Date";
+    IoRestorecommerceFilterFilterValueType[IoRestorecommerceFilterFilterValueType["Array"] = 4] = "Array";
+})(IoRestorecommerceFilterFilterValueType || (IoRestorecommerceFilterFilterValueType = {}));
+export var IoRestorecommerceFilterFilterOpOperator;
+(function (IoRestorecommerceFilterFilterOpOperator) {
+    IoRestorecommerceFilterFilterOpOperator[IoRestorecommerceFilterFilterOpOperator["And"] = 0] = "And";
+    IoRestorecommerceFilterFilterOpOperator[IoRestorecommerceFilterFilterOpOperator["Or"] = 1] = "Or";
+})(IoRestorecommerceFilterFilterOpOperator || (IoRestorecommerceFilterFilterOpOperator = {}));
+export var IoRestorecommerceResourcebaseFilterOpOperator;
+(function (IoRestorecommerceResourcebaseFilterOpOperator) {
+    IoRestorecommerceResourcebaseFilterOpOperator[IoRestorecommerceResourcebaseFilterOpOperator["And"] = 0] = "And";
+    IoRestorecommerceResourcebaseFilterOpOperator[IoRestorecommerceResourcebaseFilterOpOperator["Or"] = 1] = "Or";
+})(IoRestorecommerceResourcebaseFilterOpOperator || (IoRestorecommerceResourcebaseFilterOpOperator = {}));
+export var ModeType;
+(function (ModeType) {
+    ModeType["Create"] = "CREATE";
+    ModeType["Update"] = "UPDATE";
+    ModeType["Upsert"] = "UPSERT";
+})(ModeType || (ModeType = {}));
+export var SubscriptionAction;
+(function (SubscriptionAction) {
+    SubscriptionAction["Created"] = "CREATED";
+    SubscriptionAction["Updated"] = "UPDATED";
+    SubscriptionAction["Deleted"] = "DELETED";
+})(SubscriptionAction || (SubscriptionAction = {}));

package/dist/modules/identity/gql/schema.js

@@ -0,0 +1,5 @@
+import { registerTypings, subServices } from './types.js';
+import { generateSubServiceSchemas } from '../../../gql/protos/index.js';
+import { namespace } from '../interfaces.js';
+registerTypings();
+export const schema = (cfg) => generateSubServiceSchemas(subServices, cfg, namespace, 'Identity');

package/dist/modules/identity/gql/types.d.ts

@@ -0,0 +1,3 @@
+import { type ProtoMetadata } from '../../../gql/protos/index.js';
+export declare const subServices: ProtoMetadata[];
+export declare const registerTypings: () => void;

package/dist/modules/identity/gql/types.js

@@ -0,0 +1,18 @@
+import { protoMetadata as metaPackageIoRestorecommerceUser } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/user.js';
+import { protoMetadata as metaPackageIoRestorecommerceRole } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/role.js';
+import { protoMetadata as metaPackageIoRestorecommerceAuthentication_log } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/authentication_log.js';
+import { protoMetadata as metaPackageIoRestorecommerceToken } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/token.js';
+import { protoMetadata as metaPackageIoRestorecommerceOauth } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/oauth.js';
+import { registerPackagesRecursive } from '../../../gql/protos/index.js';
+import { registerProtoMeta } from '@restorecommerce/kafka-client';
+export const subServices = [
+    metaPackageIoRestorecommerceUser,
+    metaPackageIoRestorecommerceRole,
+    metaPackageIoRestorecommerceAuthentication_log,
+    metaPackageIoRestorecommerceToken,
+    metaPackageIoRestorecommerceOauth,
+];
+export const registerTypings = () => {
+    registerPackagesRecursive(...subServices);
+    registerProtoMeta(...subServices);
+};

package/dist/modules/identity/grpc/index.d.ts

@@ -0,0 +1,15 @@
+import { RestoreCommerceGrpcClient } from '@restorecommerce/rc-grpc-clients';
+import { type UserServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/user.js';
+import { type RoleServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/role.js';
+import { type AuthenticationLogServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/authentication_log.js';
+import { type TokenServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/token.js';
+import { type OAuthServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/oauth.js';
+import { type GrpcClientConfig } from '@restorecommerce/grpc-client';
+export declare class IdentitySrvGrpcClient extends RestoreCommerceGrpcClient {
+    readonly user: UserServiceClient;
+    readonly role: RoleServiceClient;
+    readonly authentication_log: AuthenticationLogServiceClient;
+    readonly token: TokenServiceClient;
+    readonly oauth: OAuthServiceClient;
+    constructor(address: string, cfg: GrpcClientConfig);
+}

package/dist/modules/identity/grpc/index.js

@@ -0,0 +1,16 @@
+import { RestoreCommerceGrpcClient } from '@restorecommerce/rc-grpc-clients';
+import { UserServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/user.js';
+import { RoleServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/role.js';
+import { AuthenticationLogServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/authentication_log.js';
+import { TokenServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/token.js';
+import { OAuthServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/oauth.js';
+export class IdentitySrvGrpcClient extends RestoreCommerceGrpcClient {
+    constructor(address, cfg) {
+        super(address, cfg);
+        this.user = this.createClient(cfg, UserServiceDefinition, this.channel);
+        this.role = this.createClient(cfg, RoleServiceDefinition, this.channel);
+        this.authentication_log = this.createClient(cfg, AuthenticationLogServiceDefinition, this.channel);
+        this.token = this.createClient(cfg, TokenServiceDefinition, this.channel);
+        this.oauth = this.createClient(cfg, OAuthServiceDefinition, this.channel);
+    }
+}

package/dist/modules/identity/index.d.ts

@@ -0,0 +1,4 @@
+import { type IdentityConfig } from './interfaces.js';
+export { type OIDCConfig } from './oidc/index.js';
+export type { IdentityModule, IdentityConfig, IdentityContext } from './interfaces.js';
+export declare const identityModule: import("../../interfaces.js").FacadeModuleFactory<IdentityConfig, import("./interfaces.js").IdentityContext>;

package/dist/modules/identity/index.js

@@ -0,0 +1,54 @@
+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 { createFacadeModuleFactory } from '../../utils.js';
+import { FederatedResourceSchema } from './gql/federation.js';
+import { createOIDC } from './oidc/index.js';
+import { setupApiKey } from './api-key/api-key.js';
+import { IdentitySrvGrpcClient } from './grpc/index.js';
+import { createOAuth } from './oauth/oauth.js';
+import mount from 'koa-mount';
+export const identityModule = createFacadeModuleFactory('identity', (facade, config) => {
+    const identitySrvClient = new IdentitySrvGrpcClient(config.config.client.address, Object.assign(Object.assign({}, config.config.client), { logger: facade.logger }));
+    if (!!config.apiKey) {
+        const apiKey = setupApiKey({
+            logger: facade.logger,
+            apiKey: config.apiKey
+        });
+        if (apiKey) {
+            facade.koa.use(apiKey.router.routes());
+            facade.koa.use(apiKey.app);
+        }
+    }
+    if (config.oidc) {
+        const { provider, router } = createOIDC({
+            identitySrvClient,
+            env: facade.env,
+            logger: facade.logger,
+            config: config.oidc
+        });
+        facade.koa.use(router.routes());
+        facade.koa.use(mount(provider.app));
+    }
+    if (config.oauth) {
+        facade.koa.use(createOAuth().routes());
+    }
+    const identity = {
+        client: identitySrvClient
+    };
+    facade.koa.context.identitySrvClient = identitySrvClient;
+    facade.addApolloService({
+        name: 'identity',
+        schema: FederatedResourceSchema(config.config)
+    });
+    facade.koa.use((ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.identity = identity;
+        yield next();
+    }));
+});

package/dist/modules/identity/interfaces.d.ts

@@ -0,0 +1,22 @@
+import { type GrpcClientConfig } from '@restorecommerce/grpc-client';
+import { type FacadeContext, type FacadeModule } from '../../interfaces.js';
+import { type OIDCConfig } from './oidc/index.js';
+import { type ServiceConfig } from '../../gql/protos/index.js';
+import { type IdentitySrvGrpcClient } from './grpc/index.js';
+export interface IdentityServiceConfig extends ServiceConfig {
+    root: boolean;
+}
+export interface IdentityConfig {
+    config: IdentityServiceConfig;
+    identitySrvClientConfig: GrpcClientConfig;
+    oidc?: OIDCConfig;
+    apiKey?: boolean | string;
+    oauth?: boolean;
+}
+export interface IdentityContext extends FacadeContext {
+    identity: {
+        client: IdentitySrvGrpcClient;
+    };
+}
+export type IdentityModule = FacadeModule<IdentityContext>;
+export declare const namespace = "identity";

package/dist/modules/identity/interfaces.js

@@ -0,0 +1 @@
+export const namespace = 'identity';

package/dist/modules/identity/oauth/oauth.d.ts

@@ -0,0 +1,11 @@
+import type KoaRouter from 'koa-router';
+import { type IdentityContext } from '../interfaces.js';
+import { type User } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/user.js';
+export declare const layout: (context: {
+    body: string;
+    title: string;
+}) => Promise<string>;
+export declare const register: (email: string) => Promise<string>;
+export declare const login: (links: any) => Promise<string>;
+export declare const account: (user: User) => Promise<string>;
+export declare const createOAuth: () => KoaRouter<{}, IdentityContext>;

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

@@ -0,0 +1,170 @@
+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);
+    }
+    return layoutHbs(context);
+});
+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', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.type = 'html';
+        ctx.body = yield login((yield ctx.identitySrvClient.oauth.generateLinks({})).links);
+        return 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', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.body = (yield ctx.identitySrvClient.oauth.generateLinks({})).links;
+        return 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 = yield ids.user.findByToken({
+            token
+        });
+        if (!user || !user.payload) {
+            ctx.body = 'user not logged in';
+            return next();
+        }
+        ctx.type = 'html';
+        ctx.body = yield account(user.payload);
+        return 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 = yield ids.user.register(RegisterRequest.fromPartial({
+            email: body.email,
+            name: body.username,
+            firstName: body.first_name,
+            lastName: body.last_name,
+            password: body.password,
+            userType: UserType.INDIVIDUAL_USER,
+            guest: false,
+        }));
+        if (user.payload) {
+            const token = yield upsertUserToken(ids, user.payload.id);
+            ctx.cookies.set('token', token);
+            ctx.status = 303;
+            ctx.redirect('/oauth2-account');
+            ctx.body = 'Redirecting to account page';
+            return next();
+        }
+        if (user.status) {
+            ctx.body = user.status.message;
+        }
+        return next();
+    }));
+    router.get('/oauth2/:service', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const ids = ctx.identitySrvClient;
+        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 = yield register(user.email || '');
+            return next();
+        }
+        ctx.cookies.set('token', user.token.token);
+        ctx.status = 303;
+        ctx.redirect('/oauth2-account');
+        ctx.body = 'Redirecting to account page';
+        return next();
+    }));
+    return router;
+};

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,135 @@
+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);
+export function createIdentityServiceAdapterClass(remoteTokenService, logger, localTokenServiceFactory) {
+    return class IdentityServiceAdapter {
+        constructor(type) {
+            this.type = type;
+            this.localTokenService = localTokenServiceFactory ? localTokenServiceFactory(type) : new InMemoryAdapter(type);
+        }
+        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);
+                    }
+                }
+                else {
+                    yield this.localTokenService.consume(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);
+                    }
+                }
+                else {
+                    yield this.localTokenService.destroy(id);
+                }
+            });
+        }
+        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;
+                    }
+                }
+                else {
+                    return yield this.localTokenService.find(id);
+                }
+            });
+        }
+        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
+        findByUserCode(userCode) {
+            return __awaiter(this, arguments, void 0, function* () {
+                logger.error('Finding br UserCode is unsupported', this.type, ...arguments);
+                throw new Error('UNSUPPORTED');
+            });
+        }
+        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);
+                    }
+                }
+                else {
+                    return this.localTokenService.upsert(id, payload, expiresIn * 1000);
+                }
+            });
+        }
+        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);
+                    }
+                }
+            });
+        }
+    };
+}

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

@@ -0,0 +1,16 @@
+import { type Adapter, type AdapterPayload } from 'oidc-provider';
+export declare class InMemoryAdapter implements Adapter {
+    private type;
+    constructor(type: string);
+    private tokenStorage;
+    private sessionStorage;
+    private grantIdStorage;
+    private key;
+    upsert(id: string, payload: AdapterPayload, expiresIn: number): Promise<void | undefined>;
+    findByUserCode(userCode: string): Promise<void | AdapterPayload | undefined>;
+    find(id: string): Promise<void | AdapterPayload | undefined>;
+    findByUid(uid: string): Promise<void | AdapterPayload | undefined>;
+    consume(id: string): Promise<void | undefined>;
+    destroy(id: string): Promise<void | undefined>;
+    revokeByGrantId(grantId: string): Promise<void | undefined>;
+}

package/dist/modules/identity/oidc/in-memory-adapter.js

@@ -0,0 +1,85 @@
+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 { LRUCache } from 'lru-cache';
+import { epochTime } from './utils.js';
+export class InMemoryAdapter {
+    constructor(type) {
+        this.type = type;
+        this.tokenStorage = new LRUCache({ max: 1000 });
+        this.sessionStorage = new LRUCache({ max: 1000 });
+        this.grantIdStorage = new LRUCache({ max: 1000 });
+    }
+    key(id) {
+        return `${this.type}:${id}`;
+    }
+    upsert(id, payload, expiresIn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this.key(id);
+            if (this.type === 'Session' && payload.uid) {
+                this.sessionStorage.set(payload.uid, id, {
+                    ttl: expiresIn * 1000
+                });
+            }
+            const { grantId, userCode } = payload;
+            if (grantId) {
+                this.grantIdStorage.set(grantId, [key]);
+                const grant = this.grantIdStorage.get(grantId);
+                if (!grant) {
+                    this.grantIdStorage.set(grantId, [key]);
+                }
+                else {
+                    grant.push(key);
+                }
+            }
+            if (userCode) {
+                throw 'UNSUPPORTED';
+            }
+            this.tokenStorage.set(key, payload, {
+                ttl: expiresIn * 1000
+            });
+        });
+    }
+    findByUserCode(userCode) {
+        throw new Error('UNSUPPORTED');
+    }
+    find(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.tokenStorage.get(this.key(id));
+        });
+    }
+    findByUid(uid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = yield this.sessionStorage.get(uid);
+            return id ? this.find(id) : undefined;
+        });
+    }
+    consume(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this.tokenStorage.get(this.key(id));
+            if (payload) {
+                payload.consumed = epochTime();
+            }
+        });
+    }
+    destroy(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.tokenStorage.delete(this.key(id));
+        });
+    }
+    revokeByGrantId(grantId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const grant = this.grantIdStorage.get(grantId);
+            if (grant) {
+                grant.forEach((token) => this.tokenStorage.delete(token));
+                this.grantIdStorage.delete(grantId);
+            }
+        });
+    }
+}