@restorecommerce/facade 1.3.9 → 1.3.10

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

@@ -0,0 +1,97 @@
+export var IoRestorecommerceFulfillmentState;
+(function (IoRestorecommerceFulfillmentState) {
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["Failed"] = 0] = "Failed";
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["Invalid"] = 1] = "Invalid";
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["Created"] = 2] = "Created";
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["Submitted"] = 3] = "Submitted";
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["InTransit"] = 4] = "InTransit";
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["Fulfilled"] = 5] = "Fulfilled";
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["Withdrawn"] = 6] = "Withdrawn";
+    IoRestorecommerceFulfillmentState[IoRestorecommerceFulfillmentState["Cancelled"] = 7] = "Cancelled";
+})(IoRestorecommerceFulfillmentState || (IoRestorecommerceFulfillmentState = {}));
+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 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 IoRestorecommerceInvoicePaymentState;
+(function (IoRestorecommerceInvoicePaymentState) {
+    IoRestorecommerceInvoicePaymentState[IoRestorecommerceInvoicePaymentState["Unpayed"] = 0] = "Unpayed";
+    IoRestorecommerceInvoicePaymentState[IoRestorecommerceInvoicePaymentState["Payed"] = 1] = "Payed";
+})(IoRestorecommerceInvoicePaymentState || (IoRestorecommerceInvoicePaymentState = {}));
+export var IoRestorecommerceProductAssociationType;
+(function (IoRestorecommerceProductAssociationType) {
+    IoRestorecommerceProductAssociationType[IoRestorecommerceProductAssociationType["Miscellaneous"] = 0] = "Miscellaneous";
+    IoRestorecommerceProductAssociationType[IoRestorecommerceProductAssociationType["Accessory"] = 1] = "Accessory";
+    IoRestorecommerceProductAssociationType[IoRestorecommerceProductAssociationType["Recommendation"] = 2] = "Recommendation";
+})(IoRestorecommerceProductAssociationType || (IoRestorecommerceProductAssociationType = {}));
+export var SubscriptionAction;
+(function (SubscriptionAction) {
+    SubscriptionAction["Created"] = "CREATED";
+    SubscriptionAction["Updated"] = "UPDATED";
+    SubscriptionAction["Deleted"] = "DELETED";
+})(SubscriptionAction || (SubscriptionAction = {}));

package/dist/modules/fulfillment/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, 'Fulfillment');

package/dist/modules/fulfillment/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/fulfillment/gql/types.js

@@ -0,0 +1,12 @@
+import { protoMetadata as metaPackageIoRestorecommerceFulfillment } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/fulfillment.js';
+import { protoMetadata as metaPackageIoRestorecommerceFulfillmentCourier } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/fulfillment_courier.js';
+import { protoMetadata as metaPackageIoRestorecommerceFulfillmentProduct } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/fulfillment_product.js';
+import { registerPackagesRecursive } from '../../../gql/protos/index.js';
+export const subServices = [
+    metaPackageIoRestorecommerceFulfillment,
+    metaPackageIoRestorecommerceFulfillmentCourier,
+    metaPackageIoRestorecommerceFulfillmentProduct
+];
+export const registerTypings = () => {
+    registerPackagesRecursive(...subServices);
+};

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

@@ -0,0 +1,9 @@
+import { RestoreCommerceGrpcClient } from '@restorecommerce/rc-grpc-clients';
+import { type FulfillmentServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/fulfillment.js';
+import { type FulfillmentCourierServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/fulfillment_courier.js';
+import { type GrpcClientConfig } from '@restorecommerce/grpc-client';
+export declare class FulfillmentSrvGrpcClient extends RestoreCommerceGrpcClient {
+    readonly fulfillment: FulfillmentServiceClient;
+    readonly fulfillment_courier: FulfillmentCourierServiceClient;
+    constructor(address: string, cfg: GrpcClientConfig);
+}

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

@@ -0,0 +1,10 @@
+import { RestoreCommerceGrpcClient } from '@restorecommerce/rc-grpc-clients';
+import { FulfillmentServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/fulfillment.js';
+import { FulfillmentCourierServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/fulfillment_courier.js';
+export class FulfillmentSrvGrpcClient extends RestoreCommerceGrpcClient {
+    constructor(address, cfg) {
+        super(address, cfg);
+        this.fulfillment = this.createClient(cfg, FulfillmentServiceDefinition, this.channel);
+        this.fulfillment_courier = this.createClient(cfg, FulfillmentCourierServiceDefinition, this.channel);
+    }
+}

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

@@ -0,0 +1,2 @@
+import { type FulfillmentConfig } from './interfaces.js';
+export declare const fulfillmentModule: import("../../interfaces.js").FacadeModuleFactory<FulfillmentConfig, import("./interfaces.js").FulfillmentContext>;

package/dist/modules/fulfillment/index.js

@@ -0,0 +1,26 @@
+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 { FederatedFulfillmentSchema } from './gql/federation.js';
+import { namespace } from './interfaces.js';
+import { FulfillmentSrvGrpcClient } from './grpc/index.js';
+import { createFacadeModuleFactory } from '../../utils.js';
+export const fulfillmentModule = createFacadeModuleFactory(namespace, (facade, config) => {
+    const fulfillment = {
+        client: new FulfillmentSrvGrpcClient(config.config.client.address, Object.assign(Object.assign({}, config.config.client), { logger: facade.logger }))
+    };
+    facade.addApolloService({
+        name: namespace,
+        schema: FederatedFulfillmentSchema(config.config)
+    });
+    facade.koa.use((ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.fulfillment = fulfillment;
+        yield next();
+    }));
+});

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

@@ -0,0 +1,16 @@
+import { type FulfillmentSrvGrpcClient } from './grpc/index.js';
+import { type ServiceConfig } from '../../gql/protos/index.js';
+import { type FacadeModule, type FacadeContext } from '../../interfaces.js';
+export interface FulfillmentServiceConfig extends ServiceConfig {
+    root: boolean;
+}
+export interface FulfillmentConfig {
+    config: FulfillmentServiceConfig;
+}
+export interface FulfillmentContext extends FacadeContext {
+    access_control: {
+        client: FulfillmentSrvGrpcClient;
+    };
+}
+export type FulfillmentModule = FacadeModule<FulfillmentContext>;
+export declare const namespace = "fulfillment";

package/dist/modules/fulfillment/interfaces.js

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

package/dist/modules/identity/api-key/api-key.d.ts

@@ -0,0 +1,11 @@
+import { type Logger } from 'winston';
+import type Application from 'koa';
+export interface APIParams {
+    apiKey?: boolean | string;
+    logger: Logger;
+}
+export declare let bootstrapApiKey: string | undefined;
+export declare const setupApiKey: ({ apiKey, logger }: APIParams) => {
+    router: any;
+    app: Application.Middleware<any>;
+} | undefined;

package/dist/modules/identity/api-key/api-key.js

@@ -0,0 +1,137 @@
+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 * as uuid from 'uuid';
+import { Events, registerProtoMeta } from '@restorecommerce/kafka-client';
+import { createServiceConfig } from '@restorecommerce/service-config';
+import { protoMetadata as commandInterfaceMeta } from '@restorecommerce/rc-grpc-clients/dist/generated-server/io/restorecommerce/commandinterface.js';
+// const Router = require('koa-router');
+import Router from 'koa-router';
+// import controller from './controller/index.js';
+const router = new Router();
+export let bootstrapApiKey;
+const API_KEY_COMMAND_NAME = 'set_api_key';
+const API_KEY_COMMAND_EVENT = 'setApiKeyCommand';
+const API_KEY_COMMAND_RESPONSE = 'setApiKeyResponse';
+const COMMAND_TOPIC_NAME = 'io.restorecommerce.command';
+registerProtoMeta(commandInterfaceMeta);
+const exectueSetAPIKeyCommand = (apiKey, logger) => __awaiter(void 0, void 0, void 0, function* () {
+    const cfg = createServiceConfig(process.cwd());
+    if (apiKey && cfg.get('events:kafka')) {
+        let payload = JSON.stringify({ authentication: { apiKey } });
+        const eventObject = {
+            name: API_KEY_COMMAND_NAME,
+            payload: {}
+        };
+        let eventPayload = Buffer.from(payload).toString('base64');
+        eventObject.payload = {
+            type_url: 'payload',
+            value: eventPayload
+        };
+        const events = new Events(cfg.get('events:kafka'), logger);
+        yield events.start();
+        const commandResponses = [];
+        // preparing event listener for system commands' responses
+        const responseListener = (msg, context, config, eventName) => __awaiter(void 0, void 0, void 0, function* () {
+            const payload = msg.payload;
+            let decodedMsg = {};
+            try {
+                if (payload && payload.value) {
+                    decodedMsg = JSON.parse(Buffer.from(payload.value, 'base64').toString()); // google.protobuf.Any
+                }
+                logger.info('Received command response from services', JSON.stringify(msg.services), JSON.stringify(decodedMsg));
+                commandResponses.push({
+                    services: msg.services,
+                    response: decodedMsg
+                });
+            }
+            catch (err) {
+                // some response-handling logic
+                logger.error('Invalid message format in event:', eventName);
+                throw err;
+            }
+        });
+        const commandTopic = yield events.topic(COMMAND_TOPIC_NAME);
+        yield commandTopic.on(API_KEY_COMMAND_RESPONSE, responseListener);
+        yield commandTopic.emit(API_KEY_COMMAND_EVENT, eventObject);
+        let resp = yield new Promise((resolve, reject) => {
+            setTimeout(() => {
+                commandTopic.removeAllListeners(API_KEY_COMMAND_RESPONSE);
+                resolve({
+                    responses: commandResponses
+                });
+            }, 3000);
+        });
+        return resp;
+    }
+    else {
+        logger.info('Kafka configuration missing for sync ApiKey');
+        return {
+            responses: [{ response: 'Api Key not synced' }]
+        };
+    }
+});
+const initApiKey = (logger, apiKey) => {
+    if (apiKey === true) {
+        bootstrapApiKey = uuid.v4().replace(/-/g, '');
+    }
+    else {
+        bootstrapApiKey = apiKey;
+    }
+    exectueSetAPIKeyCommand(bootstrapApiKey, logger).then((resp) => {
+        logger.info('SetApiKey command response', resp);
+        logger.info(`Bootstrap API Key is: ${bootstrapApiKey}`);
+    }).catch(err => {
+        logger.error('Error executing setApiKey command', err);
+    });
+};
+export const setupApiKey = ({ apiKey, logger }) => {
+    const router = new Router();
+    try {
+        if (!!apiKey) {
+            initApiKey(logger, apiKey);
+            router.all('/deleteApiKey', (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+                if (bootstrapApiKey) {
+                    if (ctx.apiKeyAuthorization === 'Bearer ' + bootstrapApiKey) {
+                        ctx.body = 'api key deleted!';
+                        logger.warn('Bootstrap API Key deleted!');
+                        bootstrapApiKey = undefined;
+                    }
+                    else {
+                        ctx.body = 'permission denied';
+                        ctx.status = 403;
+                    }
+                }
+                else {
+                    ctx.body = 'api key is already deleted!';
+                    ctx.status = 400;
+                }
+                yield next();
+            }));
+            return {
+                router,
+                app: (context, next) => __awaiter(void 0, void 0, void 0, function* () {
+                    if ('authorization' in context.headers) {
+                        const auth = context.headers.authorization.split(' ');
+                        if (auth.length === 2 && auth[0].toLowerCase() === 'bearer') {
+                            if (auth[1] === bootstrapApiKey) {
+                                context.apiKeyAuthorization = 'Bearer ' + bootstrapApiKey;
+                            }
+                        }
+                    }
+                    yield next();
+                })
+            };
+        }
+    }
+    catch (ex) {
+        logger.error(ex);
+    }
+    return undefined;
+};

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

@@ -0,0 +1,2 @@
+import { type IdentityServiceConfig } from '../interfaces.js';
+export declare const FederatedResourceSchema: (cfg: IdentityServiceConfig) => import("../../../gql/protos/types.js").FederatedSchemaWithResolvers;

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

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

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

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