@restorecommerce/facade 1.3.9 → 1.3.11

package/dist/index.js

@@ -0,0 +1,315 @@
+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 { createLogger } from '@restorecommerce/logger';
+import { ServerResponse } from 'node:http';
+import Koa from 'koa';
+import { ApolloServer } from '@apollo/server';
+import { koaMiddleware } from '@as-integrations/koa';
+import { GraphQLSchema, printSchema } from 'graphql';
+import { ApolloGateway, LocalGraphQLDataSource, RemoteGraphQLDataSource, IntrospectAndCompose } from '@apollo/gateway';
+import { facadeStatusModule } from './modules/index.js';
+/* eslint-disable */
+import { ApolloServerPluginDrainHttpServer } from '@apollo/server/plugin/drainHttpServer';
+/* eslint-disable */
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+import { createServer } from 'node:http';
+import { WebSocketServer } from 'ws';
+/* eslint-disable */
+import { useServer } from 'graphql-ws/lib/use/ws';
+import _ from 'lodash';
+import { makeExecutableSchema } from 'graphql-tools';
+import { gql } from 'graphql-tag';
+import { mergeSubscribeIntoSchema } from './gql/protos/index.js';
+import compose from 'koa-compose';
+import { setUseSubscriptions } from './gql/protos/utils.js';
+import bodyParser from 'koa-bodyparser';
+import cors from '@koa/cors';
+import graphqlUploadKoa from 'graphql-upload/graphqlUploadKoa.mjs';
+import Router from 'koa-router';
+export * from './modules/index.js';
+export * from './middlewares/index.js';
+export * from './interfaces.js';
+export * from './utils.js';
+export * from './gql/index.js';
+export class RestoreCommerceFacade {
+    constructor({ koa, logger, port, hostname, env, kafka, fileUploadOptions }) {
+        this.apolloServices = {};
+        this.allResolvers = {};
+        this._initialized = false;
+        this.modules = [];
+        this.startFns = [];
+        this.stopFns = [];
+        this.logger = logger;
+        this.port = port !== null && port !== void 0 ? port : 5000;
+        this.hostname = hostname !== null && hostname !== void 0 ? hostname : '127.0.0.1';
+        this.koa = koa;
+        this.env = env !== null && env !== void 0 ? env : 'development';
+        this.kafkaConfig = kafka;
+        this.fileUploadOptionsConfig = fileUploadOptions;
+        setUseSubscriptions(!!kafka);
+    }
+    get server() {
+        return this._server;
+    }
+    get address() {
+        var _a;
+        const address = (_a = this._server) === null || _a === void 0 ? void 0 : _a.address();
+        if (address && typeof address === 'object') {
+            return address;
+        }
+        return undefined;
+    }
+    get listening() {
+        return !!this._server && this._server.listening;
+    }
+    useMiddleware(middleware) {
+        this.koa.use(middleware);
+        return this;
+    }
+    useModule(module) {
+        if (this.modules.some(m => module.moduleName === m.moduleName)) {
+            throw new Error(`module ${module.moduleName} already loaded`);
+        }
+        this.modules.push(module);
+        module(this);
+        return this;
+    }
+    supportsModule(module) {
+        return this.modules.some(m => module.moduleName === m.moduleName);
+    }
+    addApolloService({ name, schema, url }) {
+        if (schema instanceof GraphQLSchema) {
+            this.apolloServices[name] = { schema, url };
+        }
+        else if ('federatedSchema' in schema && 'resolvers' in schema) {
+            this.apolloServices[name] = { schema: schema.federatedSchema, url };
+            this.allResolvers = _.merge(this.allResolvers, schema.resolvers);
+        }
+    }
+    onStart(fn) {
+        debugger;
+        this.startFns.push(fn);
+    }
+    onStop(fn) {
+        this.stopFns.push(fn);
+    }
+    runFnQueue(fns) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _fns = [...fns];
+            const runQueue = () => __awaiter(this, void 0, void 0, function* () {
+                const fn = _fns.shift();
+                if (fn) {
+                    try {
+                        yield fn();
+                    }
+                    catch (error) {
+                        this.logger.error('Error in start/stop function', error);
+                    }
+                    yield runQueue();
+                }
+            });
+            yield runQueue();
+        });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._initialized) {
+                this.runFnQueue(this.startFns);
+                yield this.mountApolloServer();
+                this._initialized = true;
+            }
+            return new Promise((resolve, reject) => {
+                var _a;
+                try {
+                    (_a = this.server) === null || _a === void 0 ? void 0 : _a.listen(this.port, this.hostname, () => {
+                        const address = this.address;
+                        if (address) {
+                            this.logger.info(`Service is listening on ${address.address}:${address.port}`);
+                        }
+                        else {
+                            this.logger.info(`Service is listening`);
+                        }
+                        resolve();
+                    });
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                yield this.runFnQueue(this.stopFns);
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.close((err) => {
+                    if (err) {
+                        this.logger.error(`Error stopping service`, err);
+                        reject(err);
+                    }
+                    else {
+                        this.logger.info(`Service stopped`);
+                        this._server = undefined;
+                        resolve();
+                    }
+                });
+            }));
+        });
+    }
+    mountApolloServer() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const serviceList = Object.keys(this.apolloServices).map(key => {
+                var _a;
+                return {
+                    name: key,
+                    url: (_a = this.apolloServices[key].url) !== null && _a !== void 0 ? _a : `local`,
+                };
+            });
+            const gateway = new ApolloGateway({
+                logger: this.logger,
+                // serviceList,
+                supergraphSdl: new IntrospectAndCompose({
+                    subgraphs: serviceList
+                }),
+                debug: true,
+                buildService: ({ name, url }) => {
+                    var _a;
+                    if (url !== 'local') {
+                        return new RemoteGraphQLDataSource({
+                            url,
+                            // TODO willSendRequest
+                        });
+                    }
+                    else {
+                        const schema = (_a = this.apolloServices[name]) === null || _a === void 0 ? void 0 : _a.schema;
+                        if (schema) {
+                            return new LocalGraphQLDataSource(schema);
+                        }
+                        else {
+                            throw new Error('Invalid schema ' + name);
+                        }
+                    }
+                }
+            });
+            this._server = createServer(this.koa.callback());
+            const wsServer = new WebSocketServer({
+                server: this._server,
+                path: '/graphql',
+            });
+            let serverCleanup;
+            gateway.onSchemaLoadOrUpdate(schemaContext => {
+                const typeDefs = printSchema(new GraphQLSchema({
+                    subscription: schemaContext.apiSchema.getSubscriptionType()
+                }));
+                let schema = makeExecutableSchema({
+                    typeDefs: gql(typeDefs + `
+        type Query { sample: String }
+        `),
+                    resolvers: {
+                        Subscription: Object.assign({}, this.allResolvers['Subscription'])
+                    }
+                });
+                if ('Subscription' in this.allResolvers) {
+                    mergeSubscribeIntoSchema(schema.getSubscriptionType(), this.allResolvers['Subscription']);
+                }
+                serverCleanup = useServer({
+                    schema,
+                    context: (ctx, message, args) => __awaiter(this, void 0, void 0, function* () {
+                        const newCtx = this.koa.createContext(ctx.extra.request, new ServerResponse(ctx.extra.request));
+                        const fn = yield compose(this.koa.middleware);
+                        yield fn(newCtx);
+                        newCtx.kafkaConfig = this.kafkaConfig;
+                        newCtx.logger = this.logger;
+                        return newCtx;
+                    }),
+                }, wsServer);
+            });
+            const gqlServer = new ApolloServer({
+                gateway,
+                introspection: true,
+                allowBatchedHttpRequests: true,
+                plugins: [
+                    ApolloServerPluginDrainHttpServer({ httpServer: this._server }),
+                    ApolloServerPluginLandingPageLocalDefault({
+                        embed: true
+                    }),
+                    {
+                        serverWillStart() {
+                            return __awaiter(this, void 0, void 0, function* () {
+                                return {
+                                    drainServer() {
+                                        return __awaiter(this, void 0, void 0, function* () {
+                                            yield serverCleanup.dispose();
+                                        });
+                                    },
+                                };
+                            });
+                        },
+                    },
+                ],
+                includeStacktraceInErrorResponses: true,
+                formatError: (error) => {
+                    this.logger.error('Error while processing request', { message: error.message });
+                    this.logger.debug('Error while processing request', { error });
+                    return {
+                        message: error.message,
+                        locations: error.locations,
+                        stack: error
+                    };
+                },
+            });
+            yield gqlServer.start();
+            // set maxFile size and maximum files via Facade config of `createFacade`
+            const maxFileSize = ((_a = this.fileUploadOptionsConfig) === null || _a === void 0 ? void 0 : _a.maxFileSize) ? this.fileUploadOptionsConfig.maxFileSize : 10000000;
+            const maxFiles = ((_b = this.fileUploadOptionsConfig) === null || _b === void 0 ? void 0 : _b.maxFiles) ? this.fileUploadOptionsConfig.maxFiles : 20;
+            this.koa.use(graphqlUploadKoa({
+                maxFileSize,
+                maxFiles
+            }));
+            this.koa.use(cors());
+            this.koa.use(bodyParser());
+            const apolloGraphQLRouter = new Router();
+            apolloGraphQLRouter.all('/graphql', koaMiddleware(gqlServer, {
+                context: ({ ctx }) => __awaiter(this, void 0, void 0, function* () { return ctx; }),
+            }));
+            this.koa.use(apolloGraphQLRouter.routes());
+        });
+    }
+}
+export const createFacade = (config) => {
+    const koa = new Koa();
+    if (config.env) {
+        koa.env = config.env;
+    }
+    if (config.keys) {
+        koa.keys = config.keys;
+    }
+    let loggerCfg;
+    if (config.logger) {
+        loggerCfg = config.logger;
+        loggerCfg.esTransformer = (msg) => {
+            msg.fields = JSON.stringify(msg.fields);
+            return msg;
+        };
+    }
+    const logger = loggerCfg !== null && loggerCfg !== void 0 ? loggerCfg : createLogger(loggerCfg);
+    koa.context.logger = logger;
+    return new RestoreCommerceFacade({
+        koa,
+        logger,
+        port: config.port,
+        hostname: config.hostname,
+        env: config.env,
+        kafka: config.kafka,
+        fileUploadOptions: config.fileUploadOptions,
+    }).useModule(facadeStatusModule);
+};

package/dist/interfaces.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="koa-websocket" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type Koa from 'koa';
+import { type Logger } from 'winston';
+import { type Server } from 'node:http';
+import { type AddressInfo } from 'node:net';
+type RequireAtLeastOne<T, Keys extends keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+export interface FacadeBaseContext extends Koa.Context {
+    logger: Logger;
+    facade: Facade;
+}
+export interface FacadeModuleBase<TContext extends FacadeBaseContext = FacadeBaseContext> {
+    moduleName: string;
+}
+export interface FacadeModule<TContext extends FacadeBaseContext = FacadeBaseContext> extends FacadeModuleBase<TContext> {
+    (facade: Facade<[FacadeModule<TContext>]>): void;
+}
+export interface FacadeModuleFactory<TConfig = any, TContext extends FacadeBaseContext = FacadeBaseContext> extends FacadeModuleBase<TContext> {
+    (config: TConfig): FacadeModule<TContext>;
+}
+export type ExtractModuleContext<TModule> = TModule extends FacadeModuleFactory<infer TConfig, infer TContext> ? TContext : TModule extends FacadeModule<infer TContext> ? TContext : never;
+export type FacadeModulesContext<T extends FacadeModuleBase[]> = (T[0] extends FacadeModuleBase ? ExtractModuleContext<T[0]> : FacadeBaseContext) & (T[1] extends FacadeModuleBase ? ExtractModuleContext<T[1]> : FacadeBaseContext) & (T[2] extends FacadeModuleBase ? ExtractModuleContext<T[2]> : FacadeBaseContext) & (T[3] extends FacadeModuleBase ? ExtractModuleContext<T[3]> : FacadeBaseContext) & (T[4] extends FacadeModuleBase ? ExtractModuleContext<T[4]> : FacadeBaseContext) & (T[5] extends FacadeModuleBase ? ExtractModuleContext<T[5]> : FacadeBaseContext) & (T[6] extends FacadeModuleBase ? ExtractModuleContext<T[6]> : FacadeBaseContext) & (T[7] extends FacadeModuleBase ? ExtractModuleContext<T[7]> : FacadeBaseContext) & (T[8] extends FacadeModuleBase ? ExtractModuleContext<T[8]> : FacadeBaseContext) & (T[9] extends FacadeModuleBase ? ExtractModuleContext<T[9]> : FacadeBaseContext);
+export type FacadeContext<T extends FacadeModuleBase[] | Facade<any> = []> = T extends FacadeModuleBase[] ? FacadeModulesContext<T> : T extends Facade<infer TFacadeModules> ? FacadeModulesContext<TFacadeModules> : FacadeBaseContext;
+export interface Facade<TModules extends FacadeModuleBase[] = []> {
+    readonly logger: Logger;
+    readonly koa: Koa<any, FacadeModulesContext<TModules>>;
+    readonly server?: Server;
+    readonly address?: string | AddressInfo;
+    readonly listening: boolean;
+    readonly env: string;
+    start(): Promise<void>;
+    onStart(fn: () => Promise<void>): void;
+    onStop(fn: () => Promise<void>): void;
+    stop(): Promise<void>;
+    addApolloService({ name, schema, url }: RequireAtLeastOne<{
+        name: string;
+        url: string;
+        schema: any;
+    }, 'url' | 'schema'>): void;
+    useMiddleware<TNewState extends object = {}, TNewContext extends object = {}>(middleware: Koa.Middleware<TNewState, TNewContext & FacadeModulesContext<TModules>>): Facade<TModules>;
+    useModule<TNewModule extends FacadeModule>(mod: TNewModule): Facade<[...TModules, TNewModule]>;
+    supportsModule<TSupportedModule extends FacadeModuleBase>(mod: TSupportedModule): this is Facade<[TSupportedModule, ...TModules]> & Facade<[...TModules]>;
+}
+export interface FileUploadOptionsConfig {
+    fileUploadOptions: FileUploadOptions;
+}
+interface FileUploadOptions {
+    maxFileSize: number;
+    maxFiles: number;
+}
+export {};

package/dist/interfaces.js

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

package/dist/middlewares/index.d.ts

@@ -0,0 +1 @@
+export * from './req-res-logger/index.js';

package/dist/middlewares/index.js

@@ -0,0 +1 @@
+export * from './req-res-logger/index.js';

package/dist/middlewares/req-res-logger/index.d.ts

@@ -0,0 +1,14 @@
+import type * as koa from 'koa';
+import { type Logger } from 'winston';
+export interface ReqResLoggerOptions {
+    logger?: Logger;
+    logGraphQL?: boolean;
+    logGraphQLVariables?: boolean;
+    logResBody?: boolean;
+}
+/**
+ Middleware that logs incoming request and outgoing response
+ @param {Object} [options] - middleware options
+ @returns {Middleware}
+ */
+export declare const reqResLogger: (opts: ReqResLoggerOptions) => koa.Middleware<koa.DefaultState, koa.DefaultContext, any>;

package/dist/middlewares/req-res-logger/index.js

@@ -0,0 +1,90 @@
+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 _debug from 'debug';
+import { createLogger } from '@restorecommerce/logger';
+const debug = _debug('@restorecommerce/koa-req-res-logger');
+const getGraphQLData = (opts, body) => {
+    if (typeof body !== 'object' || !body) {
+        return;
+    }
+    const line = {};
+    if ('operationName' in body) {
+        Object.assign(line, { operationName: body.operationName });
+    }
+    if ('query' in body) {
+        Object.assign(line, { query: body.query });
+    }
+    if (opts.logGraphQLVariables === true && 'variables' in body) {
+        Object.assign(line, { variables: body.variables });
+    }
+    return line;
+};
+/**
+ Middleware that logs incoming request and outgoing response
+ @param {Object} [options] - middleware options
+ @returns {Middleware}
+ */
+export const reqResLogger = (opts) => {
+    let loggerCfg;
+    if (opts.logger) {
+        loggerCfg = opts.logger;
+        loggerCfg.esTransformer = (msg) => {
+            msg.fields = JSON.stringify(msg.fields);
+            return msg;
+        };
+    }
+    const logger = loggerCfg !== null && loggerCfg !== void 0 ? loggerCfg : createLogger(loggerCfg);
+    const fn = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const request = ctx.request;
+        debug('yield middleware: %s', reqResLogger.name);
+        const start = Date.now();
+        const reqLog = {
+            method: ctx.request.method,
+            url: ctx.request.url,
+            header: ctx.request.header
+        };
+        if (opts.logGraphQL === true && request.body) {
+            const graphQLData = getGraphQLData(opts, request.body);
+            if (graphQLData && Object.keys(graphQLData).length > 0) {
+                Object.assign(reqLog, {
+                    graphql: graphQLData
+                });
+            }
+        }
+        // Log incoming request during downstream processing
+        logger.verbose('Request', reqLog);
+        // Call next middleware in stack
+        yield next();
+        const delta = Math.ceil(Date.now() - start);
+        // Log outgoing response during upstream
+        // Generally only response successful request
+        // Error will be handled in the Koa.js error handler
+        // The response body and procTime are not logged
+        const resLog = {
+            procTime: delta,
+            status: ctx.response.status,
+            header: ctx.response.header
+        };
+        if (opts.logGraphQL === true && !('graphql' in reqLog) && request.body) {
+            const graphQLData = getGraphQLData(opts, request.body);
+            if (graphQLData && Object.keys(graphQLData).length > 0) {
+                Object.assign(resLog, {
+                    graphql: graphQLData
+                });
+            }
+        }
+        if (opts.logResBody === true) {
+            Object.assign(resLog, { body: ctx.body });
+        }
+        // `procTime` is in millisecond
+        logger.verbose('Response', resLog);
+    });
+    return fn;
+};

package/dist/modules/access-control/gql/federation.d.ts

@@ -0,0 +1,2 @@
+import { type AccessControlServiceConfig } from '../interfaces.js';
+export declare const FederatedAccessControlSchema: (cfg: AccessControlServiceConfig) => import("graphql").GraphQLSchema;

package/dist/modules/access-control/gql/federation.js

@@ -0,0 +1,13 @@
+import { gql } from 'graphql-tag';
+import { buildSubgraphSchema } from '@apollo/federation';
+import { schema } from './schema.js';
+import { namespace } from '../interfaces.js';
+import { generateSubServiceResolvers } from '../../../gql/protos/index.js';
+import { subServices } from './types.js';
+import { printSchema } from 'graphql';
+// TODO There is currently no way of building a federated schema from GraphQLSchema Object
+// See https://github.com/apollographql/apollo-server/pull/4310
+export const FederatedAccessControlSchema = (cfg) => buildSubgraphSchema({
+    typeDefs: gql(printSchema(schema(cfg))),
+    resolvers: generateSubServiceResolvers(subServices, cfg, namespace)
+});

package/dist/modules/access-control/gql/schema.d.ts

@@ -0,0 +1,2 @@
+import { type AccessControlServiceConfig } from '../interfaces.js';
+export declare const schema: (cfg: AccessControlServiceConfig) => import("graphql").GraphQLSchema;