@restorecommerce/facade 1.0.1 → 1.1.1

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.1.1](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.1.0...@restorecommerce/facade@1.1.1) (2022-10-12)
+
+
+### Bug Fixes
+
+* **facade:** regenerated schema typings for new proto files ([4e26e29](https://github.com/restorecommerce/libs/commit/4e26e2949d14dd0e2f7794b956a7d1107b8564ba))
+
+
+
+
+
+# [1.1.0](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.0.1...@restorecommerce/facade@1.1.0) (2022-10-04)
+
+
+### Bug Fixes
+
+* **facade:** switch to apollo sandbox ([e2a1713](https://github.com/restorecommerce/libs/commit/e2a17133fe5f28ba65269232fd0ffbe230e6e416))
+
+
+### Features
+
+* **facade:** add subscriptions ([d9006e9](https://github.com/restorecommerce/libs/commit/d9006e9ebcd1522a67373f8ca8bfa751c551b36f))
+
+
+
+
+
 ## [1.0.1](https://github.com/restorecommerce/libs/compare/@restorecommerce/facade@1.0.0...@restorecommerce/facade@1.0.1) (2022-08-25)
 
 **Note:** Version bump only for package @restorecommerce/facade

package/codegen/index.js

@@ -7,7 +7,7 @@ const typescriptResolversPlugin = require("@graphql-codegen/typescript-resolvers
 const core_1 = require("@graphql-codegen/core");
 async function generateSchemaTypings({ schema, outputFile, typescript, typescriptResolvers }) {
     try {
-        const codegenConfig = {
+        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,

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

@@ -0,0 +1,6 @@
+import { FederatedSchemaWithResolvers, GraphQLResolverMap, ProtoMetadata, ServiceClient, SubSpaceServiceConfig } from './types';
+import { GraphQLSchema } from 'graphql/index';
+import { GraphQLObjectType } from 'graphql';
+import { GraphQLList } from 'graphql/type/definition';
+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,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSubscribeIntoSchema = exports.buildFederatedSubscriptionSchema = void 0;
+const federation_1 = require("@apollo/federation");
+const apollo_server_koa_1 = require("apollo-server-koa");
+const index_1 = require("graphql/index");
+const graphql_1 = require("graphql");
+const definition_1 = require("graphql/type/definition");
+const resolvers_1 = require("./resolvers");
+const buildFederatedSubscriptionSchema = (subServices, config, namespace, schema) => {
+    const resolvers = (0, resolvers_1.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 = (0, federation_1.buildFederatedSchema)({
+        typeDefs: (0, apollo_server_koa_1.gql)((0, index_1.printSchema)(schema)),
+        resolvers
+    });
+    return {
+        federatedSchema,
+        resolvers
+    };
+};
+exports.buildFederatedSubscriptionSchema = buildFederatedSubscriptionSchema;
+const mergeSubscribeIntoSchema = (schema, resolvers) => {
+    if (!schema || !resolvers) {
+        return;
+    }
+    Object.entries(resolvers).forEach(([key, val]) => {
+        if (schema instanceof definition_1.GraphQLList) {
+            (0, exports.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 definition_1.GraphQLScalarType) {
+            field.subscribe = val['subscribe'];
+        }
+        else if (fieldType instanceof graphql_1.GraphQLObjectType) {
+            (0, exports.mergeSubscribeIntoSchema)(fieldType, val);
+        }
+    });
+};
+exports.mergeSubscribeIntoSchema = mergeSubscribeIntoSchema;

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

@@ -1,33 +1,11 @@
-import { GraphQLInputField, GraphQLOutputType, GraphQLResolveInfo, GraphQLSchema, ThunkObjMap } from 'graphql';
-import { GraphQLEnumType, GraphQLFieldConfig, GraphQLFieldConfigMap, GraphQLInputObjectType, GraphQLInputType } from 'graphql/type/definition';
-import { ProtoMetadata, ServiceConfig, SubSpaceServiceConfig } from './types';
-import { MethodDescriptorProto, ServiceDescriptorProto } from 'ts-proto-descriptors';
-export declare const getGQLSchema: <TSource, TContext>(method: MethodDescriptorProto) => GraphQLFieldConfig<TSource, TContext, any>;
-export declare const getGQLSchemas: <TSource, TContext>(service: ServiceDescriptorProto) => GraphQLFieldConfigMap<TSource, TContext>;
+import { GraphQLInputField, GraphQLOutputType } from 'graphql';
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLInputType } from 'graphql/type/definition';
+import { ProtoMetadata, ServiceConfig } from './types';
+import { 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 type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
-declare type ServiceClient<Context extends Pick<Context, Key>, Key extends keyof Context, T extends Record<string, any>> = {
-    [V in Key]: {
-        client: T;
-    };
-};
-export declare const getGQLResolverFunctions: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>, SRV = any, R = ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, B extends keyof T = any, NS extends keyof CTX = any>(service: ServiceDescriptorProto, key: NS, serviceKey: B, cfg: ServiceConfig) => { [key in keyof SRV]: R; };
-export declare const registerResolverFunction: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>>(namespace: string, name: string, func: ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, mutation?: boolean, subspace?: string | undefined, service?: ServiceDescriptorProto | undefined) => void;
-export declare const generateResolver: (...namespaces: string[]) => any;
-declare type SchemaBaseOrSub = ThunkObjMap<GraphQLFieldConfig<any, any>> | Map<string, ThunkObjMap<GraphQLFieldConfig<any, any>>>;
-export declare const registerResolverSchema: (namespace: string, name: string, schema: SchemaBaseOrSub, mutation: boolean | undefined, subspace: string | undefined, config: ServiceConfig) => void;
-export declare const generateSchema: (setup: {
-    prefix: string;
-    namespace: string;
-}[]) => GraphQLSchema;
 export declare const getWhitelistBlacklistConfig: (metaService: ServiceDescriptorProto, config: ServiceConfig, meta: ProtoMetadata, entity: string) => {
     queries: Set<string>;
     mutations: Set<string>;
 };
-export declare const getAndGenerateSchema: <TSource, TContext>(service: ServiceDescriptorProto, namespace: string, prefix: string, cfg: ServiceConfig, meta: ProtoMetadata) => GraphQLSchema;
-export declare const getAndGenerateResolvers: <T extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, T>, SRV = any, R = ResolverFn<any, any, ServiceClient<CTX, keyof CTX, T>, any>, NS extends keyof CTX = any>(service: ServiceDescriptorProto, namespace: NS, cfg: ServiceConfig, meta: ProtoMetadata, subspace?: string | undefined, serviceKey?: string | undefined) => { [key in keyof SRV]: R; };
-export declare const generateSubServiceSchemas: (subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string, prefix: string) => GraphQLSchema;
-export declare const generateSubServiceResolvers: <T, M extends Record<string, any>, CTX extends ServiceClient<CTX, keyof CTX, M>>(subServices: ProtoMetadata[], config: SubSpaceServiceConfig, namespace: string) => T;
-export declare function camelCase(s: string): string;
-export {};