@restorecommerce/facade 1.3.6 → 1.3.7

package/dist/gql/protos/schema.js

@@ -1,224 +0,0 @@
-import { GraphQLSchema, GraphQLNonNull, GraphQLObjectType, GraphQLString, GraphQLEnumType } from 'graphql';
-import flat from 'array.prototype.flat';
-import { getWhitelistBlacklistConfig, Mutate } from './graphql.js';
-import { capitalize, capitalizeProtoName, useSubscriptions, getServiceName } from './utils.js';
-import { getTyping } from './registry.js';
-const typeCache = new Map();
-const subscriptionAction = new GraphQLEnumType({
-    name: 'SubscriptionAction',
-    values: {
-        CREATED: { value: 'CREATED' },
-        UPDATED: { value: 'UPDATED' },
-        DELETED: { value: 'DELETED' }
-    }
-});
-const subscriptionInput = {
-    action: {
-        type: subscriptionAction
-    }
-};
-const subscriptionOutput = new GraphQLObjectType({
-    name: 'SubscriptionOutput',
-    fields: {
-        id: {
-            type: GraphQLString
-        }
-    }
-});
-export const getGQLSchema = (method) => {
-    const fields = {};
-    const responseTyping = getTyping(method.outputType);
-    if (!responseTyping) {
-        throw Error('Method doesn\'t have registered typings: ' + method.outputType);
-    }
-    if (method.outputType !== '.google.protobuf.Empty') {
-        fields['details'] = {
-            type: responseTyping.output,
-        };
-    }
-    const outName = 'Proto' + capitalizeProtoName(method.outputType);
-    let out = typeCache.get(outName);
-    if (!out) {
-        out = new GraphQLObjectType({
-            name: outName,
-            fields,
-        });
-        typeCache.set(outName, out);
-    }
-    const typing = getTyping(method.inputType);
-    if (!typing) {
-        throw Error('Method doesn\'t have registered typings: ' + method.inputType);
-    }
-    return {
-        type: out,
-        args: method.inputType === '.google.protobuf.Empty' ? undefined : {
-            input: {
-                type: new GraphQLNonNull(typing.input)
-            }
-        }
-    };
-};
-export const getGQLSchemas = (service) => {
-    var _a;
-    return (_a = service.method) === null || _a === void 0 ? void 0 : _a.reduce((obj, method) => {
-        obj[method.name] = getGQLSchema(method);
-        return obj;
-    }, {});
-};
-const namespaceResolverSchemaRegistry = new Map();
-const subscriptionFields = {};
-export const registerResolverSchema = (namespace, name, schema, mutation = false, subspace = undefined, config) => {
-    if (!namespaceResolverSchemaRegistry.has(namespace)) {
-        namespaceResolverSchemaRegistry.set(namespace, new Map());
-    }
-    if (subspace && config[subspace]) {
-        const blacklistMethods = config[subspace].methods.blacklist;
-        if (blacklistMethods.includes(name)) {
-            return;
-        }
-    }
-    if (!namespaceResolverSchemaRegistry.get(namespace).has(mutation)) {
-        namespaceResolverSchemaRegistry.get(namespace).set(mutation, new Map());
-    }
-    let space = namespaceResolverSchemaRegistry.get(namespace).get(mutation);
-    if (subspace) {
-        if (!space.has(subspace)) {
-            space.set(subspace, new Map());
-        }
-        space = space.get(subspace);
-    }
-    if (space.has(name)) {
-        if (subspace) {
-            throw new Error(`Namespace "${namespace}"."${subspace}" already contains a schema: ${name} (mutation: ${mutation})`);
-        }
-        else {
-            throw new Error(`Namespace "${namespace}" already contains a schema: ${name} (mutation: ${mutation})`);
-        }
-    }
-    // register create, update and upsert with Mutate
-    if (Mutate.indexOf(name) > -1) {
-        name = 'Mutate';
-    }
-    space.set(name, schema);
-};
-export const generateSchema = (setup) => {
-    const queryFields = {};
-    const mutationFields = {};
-    setup.forEach(s => {
-        if (!namespaceResolverSchemaRegistry.has(s.namespace)) {
-            throw new Error(`Namespace "${s.namespace}" has no registered schemas`);
-        }
-        if (namespaceResolverSchemaRegistry.get(s.namespace).has(false)) {
-            const fields = {};
-            namespaceResolverSchemaRegistry.get(s.namespace).get(false).forEach((value, key) => {
-                if (value instanceof Map) {
-                    const capitalName = capitalizeProtoName(key);
-                    fields[key] = {
-                        type: new GraphQLNonNull(new GraphQLObjectType({
-                            name: s.prefix + capitalName + 'Query',
-                            fields: Object.fromEntries(value),
-                        }))
-                    };
-                }
-                else {
-                    fields[key] = value;
-                }
-            });
-            queryFields[s.namespace] = {
-                type: new GraphQLNonNull(new GraphQLObjectType({
-                    name: s.prefix + 'Query',
-                    fields
-                }))
-            };
-        }
-        if (namespaceResolverSchemaRegistry.get(s.namespace).has(true)) {
-            const fields = {};
-            namespaceResolverSchemaRegistry.get(s.namespace).get(true).forEach((value, key) => {
-                if (value instanceof Map) {
-                    const capitalName = capitalizeProtoName(key);
-                    fields[key] = {
-                        type: new GraphQLNonNull(new GraphQLObjectType({
-                            name: s.prefix + capitalName + 'Mutation',
-                            fields: Object.fromEntries(value),
-                        }))
-                    };
-                }
-                else {
-                    fields[key] = value;
-                }
-            });
-            mutationFields[s.namespace] = {
-                type: new GraphQLNonNull(new GraphQLObjectType({
-                    name: s.prefix + 'Mutation',
-                    fields
-                }))
-            };
-        }
-    });
-    const config = {};
-    if (Object.keys(queryFields).length > 0) {
-        config.query = new GraphQLObjectType({
-            name: 'Query',
-            fields: queryFields
-        });
-    }
-    if (Object.keys(mutationFields).length > 0) {
-        config.mutation = new GraphQLObjectType({
-            name: 'Mutation',
-            fields: mutationFields
-        });
-    }
-    if (Object.keys(subscriptionFields).length > 0) {
-        config.subscription = new GraphQLObjectType({
-            name: 'Subscription',
-            fields: subscriptionFields
-        });
-    }
-    return new GraphQLSchema(Object.assign({}, config));
-};
-export const generateSubServiceSchemas = (subServices, config, namespace, prefix) => {
-    subServices.forEach((meta) => {
-        var _a;
-        meta.fileDescriptor.service.forEach(service => {
-            if (service.name) {
-                const subName = getServiceName(service.name);
-                const { mutations, queries } = getWhitelistBlacklistConfig(service, config, meta, subName);
-                const schemas = getGQLSchemas(service);
-                Object.keys(schemas).forEach(key => {
-                    registerResolverSchema(config.root ? subName : namespace, key, schemas[key], !queries.has(key) && mutations.has(key), config.root ? undefined : subName, config);
-                });
-            }
-        });
-        if (useSubscriptions) {
-            Object.entries(((_a = meta.options) === null || _a === void 0 ? void 0 : _a.messages) || {}).forEach(([messageName, option]) => {
-                if (option.options && 'kafka_subscriber' in option.options) {
-                    const fieldName = namespace + capitalize(option.options.kafka_subscriber.plural);
-                    const typing = getTyping('.' + meta.fileDescriptor.package + '.' + messageName);
-                    if (typing) {
-                        subscriptionFields[fieldName] = {
-                            // TODO Implement user lookup
-                            // type: typing?.output!,
-                            type: subscriptionOutput,
-                            args: subscriptionInput
-                        };
-                    }
-                }
-            });
-        }
-    });
-    if (config.root) {
-        return generateSchema(flat(subServices.map(meta => {
-            return meta.fileDescriptor.service.map(service => {
-                if (service.name) {
-                    const subName = getServiceName(service.name);
-                    return {
-                        prefix: prefix + subName.substring(0, 1).toUpperCase() + subName.substring(1).toLowerCase(),
-                        namespace: subName
-                    };
-                }
-                return null;
-            }).filter(s => s !== null);
-        })));
-    }
-    return generateSchema([{ prefix, namespace }]);
-};

package/dist/gql/protos/stream-to-async-iterator.d.ts

@@ -1,50 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Readable } from "stream";
-export type StreamToAsyncIteratorOptions = {
-    /** The size of each read from the stream for each iteration */
-    size?: number;
-};
-/**
- * Wraps a stream into an object that can be used as an async iterator.
- *
- * This will keep a stream in a paused state, and will only read from the stream on each
- * iteration. A size can be supplied to set an explicit call to `stream.read([size])` in
- * the options for each iteration.
- */
-export default class StreamToAsyncIterator<T = unknown> implements AsyncIterableIterator<T> {
-    /** The underlying readable stream */
-    private _stream;
-    /** Contains stream's error when stream has error'ed out */
-    private _error;
-    /** The current state of the iterator (not readable, readable, ended, errored) */
-    private _state;
-    private _size;
-    /** The rejections of promises to call when stream errors out */
-    private _rejections;
-    get closed(): boolean;
-    constructor(stream: Readable, { size }?: StreamToAsyncIteratorOptions);
-    [Symbol.asyncIterator](): this;
-    /**
-     * Returns the next iteration of data. Rejects if the stream errored out.
-     */
-    next(): Promise<IteratorResult<T, void>>;
-    /**
-     * Waits until the stream is readable. Rejects if the stream errored out.
-     * @returns Promise when stream is readable
-     */
-    private _untilReadable;
-    /**
-     * Waits until the stream is ended. Rejects if the stream errored out.
-     * @returns Promise when stream is finished
-     */
-    private _untilEnd;
-    return(): Promise<IteratorResult<T, void>>;
-    throw(err?: Error): Promise<IteratorResult<T, void>>;
-    /**
-     * Destroy the stream
-     * @param err An optional error to pass to the stream for an error event
-     */
-    close(err?: Error): void;
-    private _handleStreamError;
-    private _handleStreamEnd;
-}

package/dist/gql/protos/stream-to-async-iterator.js

@@ -1,190 +0,0 @@
-// The MIT License (MIT)
-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());
-    });
-};
-const NOT_READABLE = Symbol("not readable");
-const READABLE = Symbol("readable");
-const ENDED = Symbol("ended");
-const ERRORED = Symbol("errored");
-const STATES = {
-    notReadable: NOT_READABLE,
-    readable: READABLE,
-    ended: ENDED,
-    errored: ERRORED,
-};
-/**
- * Wraps a stream into an object that can be used as an async iterator.
- *
- * This will keep a stream in a paused state, and will only read from the stream on each
- * iteration. A size can be supplied to set an explicit call to `stream.read([size])` in
- * the options for each iteration.
- */
-export default class StreamToAsyncIterator {
-    get closed() {
-        return this._state === STATES.ended;
-    }
-    constructor(stream, { size } = {}) {
-        /** The current state of the iterator (not readable, readable, ended, errored) */
-        this._state = STATES.notReadable;
-        /** The rejections of promises to call when stream errors out */
-        this._rejections = new Set();
-        this._stream = stream;
-        this._size = size;
-        const bindMethods = ["_handleStreamEnd", "_handleStreamError"];
-        for (const method of bindMethods) {
-            Object.defineProperty(this, method, {
-                configurable: true,
-                writable: true,
-                value: this[method].bind(this),
-            });
-        }
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        stream.once("error", this._handleStreamError);
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        stream.once("end", this._handleStreamEnd);
-    }
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    /**
-     * Returns the next iteration of data. Rejects if the stream errored out.
-     */
-    next() {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (this._state) {
-                case STATES.notReadable: {
-                    let untilReadable;
-                    let untilEnd;
-                    try {
-                        untilReadable = this._untilReadable();
-                        untilEnd = this._untilEnd();
-                        yield Promise.race([
-                            untilReadable.promise,
-                            untilEnd.promise,
-                        ]);
-                    }
-                    finally {
-                        // need to clean up any hanging event listeners
-                        if (untilReadable != null) {
-                            untilReadable.close();
-                        }
-                        if (untilEnd != null) {
-                            untilEnd.close();
-                        }
-                    }
-                    return this.next();
-                }
-                case STATES.ended: {
-                    this.close();
-                    return { done: true, value: undefined };
-                }
-                case STATES.errored: {
-                    this.close();
-                    throw this._error;
-                }
-                case STATES.readable: {
-                    // stream.read returns null if not readable or when stream has ended
-                    // todo: Could add a way to ensure data-type/shape of reads to make this type safe
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    const data = this._size
-                        ? this._stream.read(this._size)
-                        : this._stream.read();
-                    if (data !== null) {
-                        return { done: false, value: data };
-                    }
-                    else {
-                        //we're no longer readable, need to find out what state we're in
-                        this._state = STATES.notReadable;
-                        // need to let event loop run to fill stream buffer
-                        yield new Promise(setImmediate);
-                        return this.next();
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * Waits until the stream is readable. Rejects if the stream errored out.
-     * @returns Promise when stream is readable
-     */
-    _untilReadable() {
-        //let is used here instead of const because the exact reference is
-        //required to remove it, this is why it is not a curried function that
-        //accepts resolve & reject as parameters.
-        let handleReadable = undefined;
-        const promise = new Promise((resolve, reject) => {
-            handleReadable = () => {
-                this._state = STATES.readable;
-                this._rejections.delete(reject);
-                resolve();
-            };
-            this._stream.once("readable", handleReadable);
-            this._rejections.add(reject);
-        });
-        const cleanup = () => {
-            if (handleReadable != null) {
-                this._stream.removeListener("readable", handleReadable);
-            }
-        };
-        return { close: cleanup, promise };
-    }
-    /**
-     * Waits until the stream is ended. Rejects if the stream errored out.
-     * @returns Promise when stream is finished
-     */
-    _untilEnd() {
-        let handleEnd = undefined;
-        const promise = new Promise((resolve, reject) => {
-            handleEnd = () => {
-                this._state = STATES.ended;
-                this._rejections.delete(reject);
-                resolve();
-            };
-            this._stream.once("end", handleEnd);
-            this._rejections.add(reject);
-        });
-        const cleanup = () => {
-            if (handleEnd != null) {
-                this._stream.removeListener("end", handleEnd);
-            }
-        };
-        return { close: cleanup, promise };
-    }
-    return() {
-        this._state = STATES.ended;
-        return this.next();
-    }
-    throw(err) {
-        this._error = err;
-        this._state = STATES.errored;
-        return this.next();
-    }
-    /**
-     * Destroy the stream
-     * @param err An optional error to pass to the stream for an error event
-     */
-    close(err) {
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        this._stream.removeListener("end", this._handleStreamEnd);
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        this._stream.removeListener("error", this._handleStreamError);
-        this._state = STATES.ended;
-        this._stream.destroy(err);
-    }
-    _handleStreamError(err) {
-        this._error = err;
-        this._state = STATES.errored;
-        for (const reject of this._rejections) {
-            reject(err);
-        }
-    }
-    _handleStreamEnd() {
-        this._state = STATES.ended;
-    }
-}

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

@@ -1,96 +0,0 @@
-import { type GrpcClientConfig } from '@restorecommerce/grpc-client';
-import { type FileDescriptorProto } from 'ts-proto-descriptors';
-import { type GraphQLSchema, type GraphQLFieldResolver, type GraphQLScalarType } from 'graphql';
-export interface GraphQLResolverMap<TContext = {}> {
-    [typeName: string]: {
-        [fieldName: string]: GraphQLFieldResolver<any, TContext, any> | {
-            requires?: string;
-            resolve: GraphQLFieldResolver<any, TContext, any>;
-        };
-    } | GraphQLScalarType | {
-        [enumValue: string]: string | number;
-    };
-}
-export declare const authSubjectType = ".io.restorecommerce.auth.Subject";
-export type ProtoMetaMessageOptions = {
-    options?: {
-        [key: string]: any;
-    };
-    fields?: {
-        [key: string]: {
-            [key: string]: any;
-        };
-    };
-    oneof?: {
-        [key: string]: {
-            [key: string]: any;
-        };
-    };
-    nested?: {
-        [key: string]: ProtoMetaMessageOptions;
-    };
-};
-export interface ProtoMetadata {
-    fileDescriptor: FileDescriptorProto;
-    references: {
-        [key: string]: any;
-    };
-    dependencies?: ProtoMetadata[];
-    options?: {
-        options?: {
-            [key: string]: any;
-        };
-        services?: {
-            [key: string]: {
-                options?: {
-                    [key: string]: any;
-                };
-                methods?: {
-                    [key: string]: {
-                        [key: string]: any;
-                    };
-                };
-            };
-        };
-        messages?: {
-            [key: string]: ProtoMetaMessageOptions;
-        };
-        enums?: {
-            [key: string]: {
-                options?: {
-                    [key: string]: any;
-                };
-                values?: {
-                    [key: string]: {
-                        [key: string]: any;
-                    };
-                };
-            };
-        };
-    };
-}
-export interface BlackListWhiteListConfig {
-    whitelist?: string[];
-    blacklist?: string[];
-}
-export interface MethodConfig {
-    methods?: BlackListWhiteListConfig;
-}
-export interface ServiceConfig {
-    client: Omit<GrpcClientConfig, 'logger'> & {
-        address: string;
-    };
-    [key: string]: any;
-}
-export interface SubSpaceServiceConfig extends ServiceConfig {
-    root: boolean;
-}
-export type ServiceClient<Context extends Pick<Context, Key>, Key extends keyof Context, T extends Record<string, any>> = {
-    [V in Key]: {
-        client: T;
-    };
-};
-export type FederatedSchemaWithResolvers = {
-    federatedSchema: GraphQLSchema;
-    resolvers: GraphQLResolverMap<any>;
-};

package/dist/gql/protos/types.js

@@ -1 +0,0 @@
-export const authSubjectType = '.io.restorecommerce.auth.Subject';

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

@@ -1,18 +0,0 @@
-import { type TypingData } from './registry.js';
-export declare const capitalizeProtoName: (name: string) => string;
-export declare const convertyCamelToSnakeCase: (entity: string) => string;
-export declare const getKeys: (obj: any) => string[];
-export declare const decodeBufferFields: (items: any[], bufferFields: string[]) => any;
-/**
- * converts enum string values to integers reading from the inputTyping
- * @param TypingData input typing
- * @param req request object from which the enum strings to be replaced
- */
-export declare const convertEnumToInt: (inputTyping: TypingData, req: any) => any;
-export declare const capitalize: (s: string) => string;
-export declare const snakeToCamel: (s: string) => string;
-export declare const camelToSnake: (serviceName: string) => string;
-export declare const getServiceName: (serviceName: string) => string;
-export declare const camelCase: (s: string) => string;
-export declare let useSubscriptions: boolean;
-export declare const setUseSubscriptions: (value: boolean) => boolean;