@restorecommerce/facade 1.3.8 → 1.3.10

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

@@ -0,0 +1,74 @@
+export var IoRestorecommerceProductAssociationType;
+(function (IoRestorecommerceProductAssociationType) {
+    IoRestorecommerceProductAssociationType[IoRestorecommerceProductAssociationType["Miscellaneous"] = 0] = "Miscellaneous";
+    IoRestorecommerceProductAssociationType[IoRestorecommerceProductAssociationType["Accessory"] = 1] = "Accessory";
+    IoRestorecommerceProductAssociationType[IoRestorecommerceProductAssociationType["Recommendation"] = 2] = "Recommendation";
+})(IoRestorecommerceProductAssociationType || (IoRestorecommerceProductAssociationType = {}));
+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/catalog/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, 'Catalog');

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

@@ -0,0 +1,16 @@
+import { protoMetadata as metaPackageIoRestorecommerceProduct } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product.js';
+import { protoMetadata as metaPackageIoRestorecommerceProduct_prototype } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product_prototype.js';
+import { protoMetadata as metaPackageIoRestorecommerceProduct_category } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product_category.js';
+import { protoMetadata as metaPackageIoRestorecommercePrice_group } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/price_group.js';
+import { protoMetadata as metaPackageIoRestorecommerceManufacturer } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/manufacturer.js';
+import { registerPackagesRecursive } from '../../../gql/protos/index.js';
+export const subServices = [
+    metaPackageIoRestorecommerceProduct,
+    metaPackageIoRestorecommerceProduct_prototype,
+    metaPackageIoRestorecommerceProduct_category,
+    metaPackageIoRestorecommercePrice_group,
+    metaPackageIoRestorecommerceManufacturer
+];
+export const registerTypings = () => {
+    registerPackagesRecursive(...subServices);
+};

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

@@ -0,0 +1,15 @@
+import { RestoreCommerceGrpcClient } from '@restorecommerce/rc-grpc-clients';
+import { type ProductServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product.js';
+import { type ProductPrototypeServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product_prototype.js';
+import { type ProductCategoryServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product_category.js';
+import { type PriceGroupServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/price_group.js';
+import { type ManufacturerServiceClient } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/manufacturer.js';
+import { type GrpcClientConfig } from '@restorecommerce/grpc-client';
+export declare class CatalogSrvGrpcClient extends RestoreCommerceGrpcClient {
+    readonly product: ProductServiceClient;
+    readonly product_prototype: ProductPrototypeServiceClient;
+    readonly product_category: ProductCategoryServiceClient;
+    readonly price_group: PriceGroupServiceClient;
+    readonly manufacturer: ManufacturerServiceClient;
+    constructor(address: string, cfg: GrpcClientConfig);
+}

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

@@ -0,0 +1,16 @@
+import { RestoreCommerceGrpcClient } from '@restorecommerce/rc-grpc-clients';
+import { ProductServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product.js';
+import { ProductPrototypeServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product_prototype.js';
+import { ProductCategoryServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/product_category.js';
+import { PriceGroupServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/price_group.js';
+import { ManufacturerServiceDefinition } from '@restorecommerce/rc-grpc-clients/dist/generated/io/restorecommerce/manufacturer.js';
+export class CatalogSrvGrpcClient extends RestoreCommerceGrpcClient {
+    constructor(address, cfg) {
+        super(address, cfg);
+        this.product = this.createClient(cfg, ProductServiceDefinition, this.channel);
+        this.product_prototype = this.createClient(cfg, ProductPrototypeServiceDefinition, this.channel);
+        this.product_category = this.createClient(cfg, ProductCategoryServiceDefinition, this.channel);
+        this.price_group = this.createClient(cfg, PriceGroupServiceDefinition, this.channel);
+        this.manufacturer = this.createClient(cfg, ManufacturerServiceDefinition, this.channel);
+    }
+}

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

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

package/dist/modules/catalog/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 { FederatedCatalogSchema } from './gql/federation.js';
+import { namespace } from './interfaces.js';
+import { CatalogSrvGrpcClient } from './grpc/index.js';
+import { createFacadeModuleFactory } from '../../utils.js';
+export const catalogModule = createFacadeModuleFactory(namespace, (facade, config) => {
+    const catalog = {
+        client: new CatalogSrvGrpcClient(config.config.client.address, Object.assign(Object.assign({}, config.config.client), { logger: facade.logger }))
+    };
+    facade.addApolloService({
+        name: namespace,
+        schema: FederatedCatalogSchema(config.config)
+    });
+    facade.koa.use((ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.catalog = catalog;
+        yield next();
+    }));
+});

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

@@ -0,0 +1,16 @@
+import { type CatalogSrvGrpcClient } from './grpc/index.js';
+import { type ServiceConfig } from '../../gql/protos/index.js';
+import { type FacadeModule, type FacadeContext } from '../../interfaces.js';
+export interface CatalogServiceConfig extends ServiceConfig {
+    root: boolean;
+}
+export interface CatalogConfig {
+    config: CatalogServiceConfig;
+}
+export interface CatalogContext extends FacadeContext {
+    catalog: {
+        client: CatalogSrvGrpcClient;
+    };
+}
+export type CatalogModule = FacadeModule<CatalogContext>;
+export declare const namespace = "catalog";

package/dist/modules/catalog/interfaces.js

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

package/dist/modules/facade-status/gql/index.d.ts

@@ -0,0 +1 @@
+export declare const FederatedExampleSchema: import("graphql").GraphQLSchema;

package/dist/modules/facade-status/gql/index.js

@@ -0,0 +1,11 @@
+import { buildSubgraphSchema } from '@apollo/federation';
+import { gql } from 'graphql-tag';
+import { printSchema } from 'graphql';
+import { resolvers } from './resolvers.js';
+import { schema } from './schema.js';
+// 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 FederatedExampleSchema = buildSubgraphSchema({
+    typeDefs: gql(printSchema(schema)),
+    resolvers
+});

package/dist/modules/facade-status/gql/resolvers.d.ts

@@ -0,0 +1,2 @@
+import { type Resolvers } from './schema.generated.js';
+export declare const resolvers: Resolvers;

package/dist/modules/facade-status/gql/resolvers.js

@@ -0,0 +1,18 @@
+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());
+    });
+};
+export const resolvers = {
+    Query: {
+        status: (_, __, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+            return ({
+                running: ctx.facade.listening
+            });
+        })
+    }
+};

package/dist/modules/facade-status/gql/schema.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLObjectType, GraphQLSchema } from 'graphql';
+export declare const FacadeStatusQueryType: GraphQLObjectType<any, any>;
+export declare const schema: GraphQLSchema;

package/dist/modules/facade-status/gql/schema.generated.d.ts

@@ -0,0 +1,109 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { FacadeStatusContext } from '../interfaces.js';
+export type Maybe<T> = T | null | undefined;
+export type InputMaybe<T> = T | null | undefined;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string | number;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+};
+/** The root of all queries */
+export type Query = {
+    __typename?: 'Query';
+    status?: Maybe<FacadeStatusType>;
+};
+/** The facade status */
+export type FacadeStatusType = {
+    __typename?: 'FacadeStatusType';
+    running: Scalars['Boolean']['output'];
+};
+export type WithIndex<TObject> = TObject & Record<string, any>;
+export type ResolversObject<TObject> = WithIndex<TObject>;
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+    subscribe: SubscriptionSubscribeFn<{
+        [key in TKey]: TResult;
+    }, TParent, TContext, TArgs>;
+    resolve?: SubscriptionResolveFn<TResult, {
+        [key in TKey]: TResult;
+    }, TContext, TArgs>;
+}
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+    subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+    resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
+}
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export type NextResolverFn<T> = () => Promise<T>;
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+/** Mapping between all available schema types and the resolvers types */
+export type ResolversTypes = ResolversObject<{
+    Query: ResolverTypeWrapper<{}>;
+    FacadeStatusType: ResolverTypeWrapper<FacadeStatusType>;
+    Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
+    String: ResolverTypeWrapper<Scalars['String']['output']>;
+}>;
+/** Mapping between all available schema types and the resolvers parents */
+export type ResolversParentTypes = ResolversObject<{
+    Query: {};
+    FacadeStatusType: FacadeStatusType;
+    Boolean: Scalars['Boolean']['output'];
+    String: Scalars['String']['output'];
+}>;
+export type QueryResolvers<ContextType = FacadeStatusContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
+    status?: Resolver<Maybe<ResolversTypes['FacadeStatusType']>, ParentType, ContextType>;
+}>;
+export type FacadeStatusTypeResolvers<ContextType = FacadeStatusContext, ParentType extends ResolversParentTypes['FacadeStatusType'] = ResolversParentTypes['FacadeStatusType']> = ResolversObject<{
+    running?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+export type Resolvers<ContextType = FacadeStatusContext> = ResolversObject<{
+    Query?: QueryResolvers<ContextType>;
+    FacadeStatusType?: FacadeStatusTypeResolvers<ContextType>;
+}>;

package/dist/modules/facade-status/gql/schema.generated.js

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

package/dist/modules/facade-status/gql/schema.js

@@ -0,0 +1,14 @@
+import { GraphQLObjectType, GraphQLSchema } from 'graphql';
+import { FacadeStatusType } from './types.js';
+export const FacadeStatusQueryType = new GraphQLObjectType({
+    name: 'Query',
+    description: 'The root of all queries',
+    fields: {
+        status: {
+            type: FacadeStatusType
+        },
+    }
+});
+export const schema = new GraphQLSchema({
+    query: FacadeStatusQueryType,
+});

package/dist/modules/facade-status/gql/types.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLObjectType } from 'graphql';
+export declare const FacadeStatusType: GraphQLObjectType<any, any>;

package/dist/modules/facade-status/gql/types.js

@@ -0,0 +1,10 @@
+import { GraphQLObjectType, GraphQLNonNull, GraphQLBoolean } from 'graphql';
+export const FacadeStatusType = new GraphQLObjectType({
+    name: 'FacadeStatusType',
+    description: 'The facade status',
+    fields: {
+        running: {
+            type: new GraphQLNonNull(GraphQLBoolean)
+        },
+    },
+});

package/dist/modules/facade-status/index.d.ts

@@ -0,0 +1,2 @@
+import { type FacadeStatusModule } from './interfaces.js';
+export declare const facadeStatusModule: FacadeStatusModule;

package/dist/modules/facade-status/index.js

@@ -0,0 +1,8 @@
+import { createFacadeModule } from '../../utils.js';
+import { FederatedExampleSchema } from './gql/index.js';
+export const facadeStatusModule = createFacadeModule('facade-status', (facade) => {
+    facade.addApolloService({
+        name: 'status',
+        schema: FederatedExampleSchema
+    });
+});

package/dist/modules/facade-status/interfaces.d.ts

@@ -0,0 +1,4 @@
+import { type FacadeModule, type FacadeContext } from '../../interfaces.js';
+export interface FacadeStatusContext extends FacadeContext {
+}
+export type FacadeStatusModule = FacadeModule<FacadeStatusContext>;

package/dist/modules/facade-status/interfaces.js

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

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

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

package/dist/modules/fulfillment/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 FederatedFulfillmentSchema = (cfg) => buildSubgraphSchema({
+    typeDefs: gql(printSchema(schema(cfg))),
+    resolvers: generateSubServiceResolvers(subServices, cfg, namespace)
+});

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

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