@restorecommerce/facade 1.3.9 → 1.3.10

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.3.10](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.3.8...@restorecommerce/facade@1.3.10) (2023-07-11)
+
+
+### Bug Fixes
+
+* enum conversion to int no longer necessary ([27dcac0](https://github.com/restorecommerce/libs/commit/27dcac03f71c3db92ecae838814dd961aa107ec3))
+* facade grpc client resolution ([4ced730](https://github.com/restorecommerce/libs/commit/4ced730977714cf30bfe45728a7e1ead78f43eca))
+* **facade:** client for renamed resource to master_data ([6929a9e](https://github.com/restorecommerce/libs/commit/6929a9e8cabbc3045047005da2c05ff44b88f2d1))
+* **facade:** convert async iterable to readable stream for file download ([a3f5118](https://github.com/restorecommerce/libs/commit/a3f511865df262495f493547a3d1cbc37b260b42))
+* nested filters for recursive field resolution ([1b6d180](https://github.com/restorecommerce/libs/commit/1b6d180b83e4efbedf54b42b20fb4b4c17996c6a))
+
+
+
+
+
 ## [1.3.8](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.3.7...@restorecommerce/facade@1.3.8) (2023-06-29)
 
 **Note:** Version bump only for package @restorecommerce/facade

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) n-fuse GmbH and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/codegen/index.d.ts

@@ -0,0 +1,12 @@
+export interface GenerateSchemaTypingsArgs {
+    schema: any;
+    outputFile: string;
+    typescript?: {
+        [key: string]: any;
+    };
+    typescriptResolvers?: {
+        contextType?: string;
+        [key: string]: any;
+    };
+}
+export declare const generateSchemaTypings: ({ schema, outputFile, typescript, typescriptResolvers }: GenerateSchemaTypingsArgs) => Promise<void>;

package/codegen/index.js

@@ -0,0 +1,43 @@
+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 fs from 'node:fs';
+import * as typescriptPlugin from '@graphql-codegen/typescript';
+import * as typescriptResolversPlugin from '@graphql-codegen/typescript-resolvers';
+import { codegen } from '@graphql-codegen/core';
+export const generateSchemaTypings = ({ schema, outputFile, typescript, typescriptResolvers }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const codegenConfig /* typings wrong?  */ = {
+            // used by a plugin internally, although the 'typescript' plugin currently
+            // returns the string output, rather than writing to a file
+            filename: outputFile,
+            schemaAst: schema,
+            documents: [],
+            plugins: [
+                {
+                    typescript: Object.assign({ maybeValue: 'T | null | undefined', inputMaybeValue: 'T | null | undefined' }, (typescript !== null && typescript !== void 0 ? typescript : {})),
+                },
+                {
+                    typescriptResolvers: Object.assign({ noSchemaStitching: true, useIndexSignature: true, federation: true }, (typescriptResolvers !== null && typescriptResolvers !== void 0 ? typescriptResolvers : {})),
+                },
+            ],
+            pluginMap: {
+                typescript: typescriptPlugin,
+                typescriptResolvers: typescriptResolversPlugin,
+            },
+            emitLegacyCommonJSImports: false
+        };
+        const output = yield codegen(codegenConfig);
+        fs.writeFileSync(outputFile, output);
+        console.log('Schema typings generated in' + outputFile);
+    }
+    catch (ex) {
+        console.error(ex);
+    }
+});

package/dist/gql/index.d.ts

@@ -0,0 +1 @@
+export * from './types/index.js';

package/dist/gql/index.js

@@ -0,0 +1 @@
+export * from './types/index.js';

package/dist/gql/protos/federation.d.ts

@@ -0,0 +1,6 @@
+import { type FederatedSchemaWithResolvers, type GraphQLResolverMap, type ProtoMetadata, type ServiceClient, type SubSpaceServiceConfig } from './types.js';
+import { type GraphQLSchema } from 'graphql/index.js';
+import { GraphQLObjectType } from 'graphql';
+import { GraphQLList } from 'graphql/type/definition.js';
+export declare const buildFederatedSubscriptionSchema: <T, M extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, M>>(subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string, schema: GraphQLSchema) => FederatedSchemaWithResolvers;
+export declare const mergeSubscribeIntoSchema: (schema: GraphQLObjectType | GraphQLList<any> | null | undefined, resolvers: GraphQLResolverMap<any>[string]) => void;

package/dist/gql/protos/federation.js

@@ -0,0 +1,46 @@
+import { buildSubgraphSchema } from '@apollo/federation';
+import { gql } from 'graphql-tag';
+import { printSchema } from 'graphql/index.js';
+import { GraphQLObjectType } from 'graphql';
+import { GraphQLList, GraphQLScalarType } from 'graphql/type/definition.js';
+import { generateSubServiceResolvers } from './resolvers.js';
+export const buildFederatedSubscriptionSchema = (subServices, config, namespace, schema) => {
+    const resolvers = generateSubServiceResolvers(subServices, config, namespace);
+    // TODO There is currently no way of building a federated schema from GraphQLSchema Object
+    // See https://github.com/apollographql/apollo-server/pull/4310
+    const federatedSchema = buildSubgraphSchema({
+        typeDefs: gql(printSchema(schema)),
+        resolvers
+    });
+    return {
+        federatedSchema,
+        resolvers
+    };
+};
+export const mergeSubscribeIntoSchema = (schema, resolvers) => {
+    if (!schema || !resolvers) {
+        return;
+    }
+    Object.entries(resolvers).forEach(([key, val]) => {
+        if (schema instanceof GraphQLList) {
+            mergeSubscribeIntoSchema(schema.ofType, val);
+            return;
+        }
+        const field = schema.getFields()[key];
+        if (!field) {
+            return;
+        }
+        if ('resolve' in val || 'subscribe' in val) {
+            field.subscribe = val['subscribe'] || field.subscribe;
+            field.resolve = val['resolve'] || field.resolve;
+            return;
+        }
+        const fieldType = field.type;
+        if (fieldType instanceof GraphQLScalarType) {
+            field.subscribe = val['subscribe'];
+        }
+        else if (fieldType instanceof GraphQLObjectType) {
+            mergeSubscribeIntoSchema(fieldType, val);
+        }
+    });
+};

package/dist/gql/protos/graphql.d.ts

@@ -0,0 +1,11 @@
+import { type GraphQLInputField, type GraphQLOutputType } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, type GraphQLInputType } from 'graphql/type/definition.js';
+import { type ProtoMetadata, type ServiceConfig } from './types.js';
+import { type ServiceDescriptorProto } from 'ts-proto-descriptors';
+export declare const Mutate: string[];
+export declare const preprocessGQLInput: (data: any, model: GraphQLInputObjectType | GraphQLEnumType | GraphQLInputField | GraphQLInputType) => Promise<any>;
+export declare const postProcessGQLValue: (data: any, model: GraphQLOutputType) => any;
+export declare const getWhitelistBlacklistConfig: (metaService: ServiceDescriptorProto, config: ServiceConfig, meta: ProtoMetadata, entity: string) => {
+    queries: Set<string>;
+    mutations: Set<string>;
+};

package/dist/gql/protos/graphql.js

@@ -0,0 +1,158 @@
+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 { GraphQLList, GraphQLNonNull, GraphQLObjectType, } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType, } from 'graphql/type/definition.js';
+export const Mutate = ['Create', 'Update', 'Upsert'];
+export const preprocessGQLInput = (data, model) => __awaiter(void 0, void 0, void 0, function* () {
+    if (model instanceof GraphQLEnumType) {
+        return data;
+    }
+    if (model instanceof GraphQLInputObjectType) {
+        if (model.name === 'IGoogleProtobufAny') {
+            // TODO Use encoded once resource base supports it
+            // const typing = getTyping(data.typeUrl);
+            // if (!typing) {
+            //   throw Error(`GoogleProtobufAny could not find input type: ${data.typeUrl}`);
+            // }
+            //
+            // const encoded = typing.processor.encode(typing.processor.fromPartial(data.value)).finish();
+            const encoded = Buffer.from(JSON.stringify(data.value));
+            return Object.assign(Object.assign({}, data), { value: encoded });
+        }
+        else {
+            const fields = model.getFields();
+            for (let key of Object.keys(fields)) {
+                if (data && key in data) {
+                    data[key] = yield preprocessGQLInput(data[key], fields[key].type);
+                }
+            }
+        }
+    }
+    if (model instanceof GraphQLScalarType) {
+        if (model.name === 'IDateTime') {
+            return new Date(data);
+        }
+    }
+    if (model instanceof GraphQLNonNull) {
+        return yield preprocessGQLInput(data, model.ofType);
+    }
+    if (model instanceof GraphQLList) {
+        for (let i = 0; i < data.length; i++) {
+            data[i] = yield preprocessGQLInput(data[i], model.ofType);
+        }
+    }
+    if (model instanceof GraphQLScalarType) {
+        switch (model.name) {
+            case 'Upload':
+                if (typeof data !== 'object') {
+                    return Buffer.from(data.toString(), 'utf8');
+                }
+                let fileData = yield data;
+                const upload = yield fileData.promise;
+                const stream = upload.createReadStream();
+                return stream;
+        }
+    }
+    return data;
+});
+export const postProcessGQLValue = (data, model) => {
+    if (model instanceof GraphQLEnumType) {
+        return data;
+    }
+    if (model instanceof GraphQLObjectType) {
+        if (model.name === 'GoogleProtobufAny' && (data === null || data === void 0 ? void 0 : data.value)) {
+            // TODO Use encoded once resource base supports it
+            const decoded = JSON.parse(data.value.toString());
+            return Object.assign(Object.assign({}, data), { value: decoded });
+        }
+        else {
+            const fields = model.getFields();
+            for (let key of Object.keys(fields)) {
+                if (data && key in data) {
+                    data[key] = postProcessGQLValue(data[key], fields[key].type);
+                }
+            }
+        }
+    }
+    if (model instanceof GraphQLNonNull) {
+        return postProcessGQLValue(data, model.ofType);
+    }
+    if (model instanceof GraphQLList) {
+        for (let i = 0; i < data.length; i++) {
+            data[i] = postProcessGQLValue(data[i], model.ofType);
+        }
+    }
+    return data;
+};
+export const getWhitelistBlacklistConfig = (metaService, config, meta, entity) => {
+    var _a, _b, _c, _d;
+    const queryList = [];
+    if (meta.options && meta.options.services && meta.options.services[metaService.name] && meta.options.services[metaService.name].methods) {
+        const methods = meta.options.services[metaService.name].methods;
+        for (const key of Object.keys(methods)) {
+            if ('is_query' in methods[key] && methods[key]['is_query']) {
+                queryList.push(key);
+            }
+        }
+    }
+    const mut = new Set(metaService.method.map(m => m.name).filter(key => queryList.indexOf(key) < 0));
+    const que = new Set(metaService.method.map(m => m.name).filter(key => queryList.indexOf(key) >= 0));
+    if (config[entity]) {
+        if ((_b = (_a = config[entity]) === null || _a === void 0 ? void 0 : _a.methods) === null || _b === void 0 ? void 0 : _b.whitelist) {
+            const whitelist = new Set(config[entity].methods.whitelist);
+            mut.forEach(key => {
+                if (whitelist.has(key)) {
+                    whitelist.delete(key);
+                }
+                else {
+                    mut.delete(key);
+                }
+            });
+            que.forEach(key => {
+                if (whitelist.has(key)) {
+                    whitelist.delete(key);
+                }
+                else {
+                    que.delete(key);
+                }
+            });
+            if (whitelist.size > 0) {
+                // TODO Log error that whitelist contains methods that don't exist
+                console.error('Whitelist contains undefined methods:', whitelist);
+            }
+        }
+        else if ((_d = (_c = config[entity]) === null || _c === void 0 ? void 0 : _c.methods) === null || _d === void 0 ? void 0 : _d.blacklist) {
+            const blacklist = new Set(config[entity].methods.blacklist);
+            mut.forEach(key => {
+                if (blacklist.has(key)) {
+                    blacklist.delete(key);
+                    mut.delete(key);
+                }
+            });
+            que.forEach(key => {
+                if (blacklist.has(key)) {
+                    blacklist.delete(key);
+                    que.delete(key);
+                }
+            });
+            if (blacklist.size > 0) {
+                // TODO Log error that blacklist contains methods that don't exist
+                console.error('Blacklist contains undefined methods:', blacklist);
+            }
+        }
+    }
+    if (Mutate.findIndex(val => mut.has(val)) > -1) {
+        mut.add('Mutate');
+    }
+    return {
+        mutations: mut,
+        queries: que
+    };
+};

package/dist/gql/protos/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './registry.js';
+export * from './graphql.js';
+export * from './federation.js';
+export * from './resolvers.js';
+export * from './schema.js';

package/dist/gql/protos/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './registry.js';
+export * from './graphql.js';
+export * from './federation.js';
+export * from './resolvers.js';
+export * from './schema.js';

package/dist/gql/protos/registry.d.ts

@@ -0,0 +1,23 @@
+import { type GraphQLEnumTypeConfig, type GraphQLInputObjectTypeConfig, GraphQLObjectType, type GraphQLObjectTypeConfig } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLScalarType } from 'graphql/type/definition.js';
+import { type ProtoMetadata, type ProtoMetaMessageOptions } from './types.js';
+import { type DescriptorProto, type EnumDescriptorProto, type MethodDescriptorProto } from 'ts-proto-descriptors';
+export interface TypingData {
+    output: GraphQLObjectType | GraphQLEnumType | GraphQLScalarType;
+    input: GraphQLInputObjectType | GraphQLEnumType | GraphQLScalarType;
+    meta: DescriptorProto | EnumDescriptorProto;
+    processor?: any;
+}
+export declare const registeredTypings: Map<string, TypingData>;
+export declare const scalarTypes: string[];
+export declare const IGoogleProtobufAny: GraphQLInputObjectType;
+export declare const clearRegistry: () => void;
+export declare const getRegisteredEnumTypings: () => string[];
+export declare const getNameSpaceTypeName: (typeName: string) => string | undefined;
+export declare const getTyping: (type: string) => TypingData | undefined;
+export declare const recursiveEnumCheck: (typeName: string, enumMap: Map<string, string>, prevFieldName: string, traversedFields: string[]) => Map<string, string>;
+export declare const registerTyping: (protoPackage: string, message: DescriptorProto, methodDef: MethodDescriptorProto[], opts?: Omit<Readonly<GraphQLObjectTypeConfig<any, any>>, 'fields'>, inputOpts?: Omit<Readonly<GraphQLInputObjectTypeConfig>, 'fields'>, messageOptions?: ProtoMetaMessageOptions) => void;
+export declare const registerEnumTyping: <T = {
+    [key: string]: any;
+}>(protoPackage: string, message: EnumDescriptorProto, opts?: Omit<Readonly<GraphQLEnumTypeConfig>, 'values'>) => void;
+export declare const registerPackagesRecursive: (...protoMetadata: ProtoMetadata[]) => void;