@nextage/nx-frame-be 1.0.1

package/build/common/graphql/generator.js

@@ -0,0 +1,385 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchema = exports.publishSubData = exports.publishUpdateSubData = exports.publishEventSubData = exports.mainSubChannel = exports.foldedEntityFields = exports.codedEntityFields = void 0;
+const utils_1 = require("../utils");
+const loader_1 = require("./loader");
+const utils_2 = require("./utils");
+exports.codedEntityFields = {
+    type: `
+    id         : ID!
+    code       : String!
+    name       : String!
+    description: String
+    startDate  : Date
+    endDate    : Date
+  `,
+    query: `
+    id         : RegExp
+    code       : RegExp
+    name       : RegExp
+    description: RegExp
+    rangeDate  : FilterDate
+    startDate  : Date
+    endDate    : Date
+  `,
+    input: `
+    code       : String
+    name       : String
+    description: String
+    startDate  : Date
+    endDate    : Date
+  `
+};
+exports.foldedEntityFields = {
+    type: `
+    id           : ID!
+    title        : String
+    name         : String
+    description  : String
+    locked       : Boolean
+    public       : Boolean
+    folder       : Boolean
+    folderId     : String
+    ownerId      : String
+    users        : [JSON]
+    organizations: [JSON]
+  `,
+    query: `
+    title        : String
+    name         : RegExp
+    description  : String
+    public       : Boolean
+    folder       : Boolean
+    folderId     : String
+  `,
+    input: `
+    title        : String
+    name         : String
+    description  : String
+    locked       : Boolean
+    public       : Boolean
+    folder       : Boolean
+    folderId     : String
+    ownerId      : String
+    users        : [JSON]
+    organizations: [JSON]
+  `
+};
+exports.mainSubChannel = 'mainCH';
+/**
+ *
+ * @param modelName
+ * @returns
+ */
+function getMethodNames(modelName) {
+    const lowerModelName = modelName[0].toLowerCase() + modelName.slice(1);
+    return {
+        count: `${lowerModelName}Count`,
+        list: `${lowerModelName}List`,
+        get: `${lowerModelName}`,
+        findOne: `findOne${modelName}`,
+        create: `create${modelName}`,
+        update: `update${modelName}`,
+        remove: `remove${modelName}`,
+        copy: `copy${modelName}`,
+        addArrayItem: `add${modelName}ArrayItem`,
+        updateArrayItem: `update${modelName}ArrayItem`,
+        removeArrayItem: `remove${modelName}ArrayItem`,
+        bulkUpdate: `bulkUpdate${modelName}`,
+        bulkRemove: `bulkRemove${modelName}`,
+    };
+}
+/**
+ *
+ * @param modelName
+ * @returns
+ */
+function getSubscriptionNames(modelName) {
+    const lowerModelName = modelName[0].toLowerCase() + modelName.slice(1);
+    return {
+        create: { id: `${lowerModelName}CreateEvent`, payload: `${lowerModelName}Added` },
+        update: { id: `${lowerModelName}UpdateEvent`, payload: `${lowerModelName}Changed` },
+        remove: { id: `${lowerModelName}RemoveEvent`, payload: `${lowerModelName}Removed` },
+        // addArrayItem   : {},
+        // updateArrayItem: {},
+        // removeArrayItem: {}
+    };
+}
+/**
+ *
+ * @param extension
+ * @returns
+ */
+function getAuth(extension = {}) {
+    const roles = { read: '', write: '' };
+    if (!extension.roles)
+        return roles;
+    if ((0, utils_1.isString)(extension.roles))
+        extension.roles = extension.roles.split(',');
+    if (Array.isArray(extension.roles))
+        extension.roles = { read: extension.roles, write: extension.roles };
+    const sr = extension.roles;
+    if ((sr.read))
+        roles.read = `(requires: "${Array.isArray(sr.read) ? sr.read.join(',') : sr.read}")`;
+    if (sr.write)
+        roles.write = `(requires: "${Array.isArray(sr.write) ? sr.write.join(',') : sr.write}")`;
+    return roles;
+}
+/**
+ *
+ * @param model
+ * @param schemaExtension
+ * @param mergeCodedEntity
+ * @param readOnly
+ * @returns
+ */
+function generateTypeDefs(ctrl, schemaExtension = {}, mergeCodedEntity, readOnly) {
+    var _a, _b, _c, _d;
+    const modelName = getModelName(ctrl.model, schemaExtension);
+    const methods = getMethodNames(modelName);
+    const subscriptions = getSubscriptionNames(modelName);
+    const roles = getAuth(schemaExtension);
+    const typeDefs = schemaExtension.typeDefs || {};
+    let dataFields = schemaExtension.fields;
+    if (dataFields && mergeCodedEntity) {
+        dataFields.type = `${exports.codedEntityFields.type}${dataFields.type}`;
+        dataFields.input = `${exports.codedEntityFields.input}${dataFields.input}`;
+        dataFields.query = `${exports.codedEntityFields.query}${dataFields.query}`;
+    }
+    else if (!dataFields)
+        dataFields = exports.codedEntityFields;
+    const baseTypeDefs = {
+        query: `
+      ${methods.count}(params: ${modelName}Query)                             : Int!            @auth${roles.read}
+      ${methods.list}(params: ${modelName}Query, pagination: OffsetPagination): [${modelName}]! @auth${roles.read}
+      ${methods.get}(id: ID!)                                                 : ${modelName}!   @auth${roles.read}
+      ${methods.findOne}(params: ${modelName}Query)                           : ${modelName}    @auth${roles.read}
+    `,
+        mutation: `
+      ${methods.create}(item: ${modelName}Input!)                             : ${modelName}! @auth${roles.write}
+      ${methods.update}(id: ID!, item: ${modelName}Input!)                    : ${modelName}! @auth${roles.write}
+      ${methods.remove}(id: ID!)                                              : ${modelName}! @auth${roles.write}
+      ${methods.copy}(id: ID!, item: ${modelName}Input!)                      : ${modelName}! @auth${roles.write}
+
+      ${methods.addArrayItem}(id: ID!, item: AddArrayElemItem!)               : ${modelName}! @auth${roles.write}
+      ${methods.updateArrayItem}(id: ID!, item: UpdateArrayElemItem!)         : ${modelName}! @auth${roles.write}
+      ${methods.removeArrayItem}(id: ID!, item: RemoveArrayElemItem!)         : ${modelName}! @auth${roles.write}
+
+      ${methods.bulkUpdate}(ids: [ID]!, items: [${modelName}Input]!)          : [${modelName}]! @auth${roles.write}
+      ${methods.bulkRemove}(ids: [ID]!)                                       : [${modelName}]! @auth${roles.write}
+    `,
+        subscription: `
+      ${subscriptions.create.id}(channelId: String!, filter: ${modelName}Query): ${modelName}! @auth${roles.read}
+      ${subscriptions.update.id}(channelId: String!, filter: ${modelName}Query): ${modelName}! @auth${roles.read}
+      ${subscriptions.remove.id}(channelId: String!, filter: ${modelName}Query): ${modelName}! @auth${roles.read}
+    `,
+        type: `
+      type ${modelName} {
+        ${dataFields.type}
+      }
+    
+      input ${modelName}Query {
+        ${dataFields.query}
+        text      : RegExp
+        pagination: OffsetPagination
+      }
+      
+      input ${modelName}Input {
+        ${dataFields.input || 'noattr: String'}
+      }
+    `
+    };
+    return {
+        query: `
+      ${baseTypeDefs.query}
+      ${(_a = typeDefs.query) !== null && _a !== void 0 ? _a : ''}
+    `,
+        mutation: `
+      ${readOnly ? '' : baseTypeDefs.mutation}
+      ${(_b = typeDefs.mutation) !== null && _b !== void 0 ? _b : ''}
+    `,
+        subscription: `
+      ${readOnly ? '' : baseTypeDefs.subscription}
+      ${(_c = typeDefs.subscription) !== null && _c !== void 0 ? _c : ''}
+    `,
+        type: `
+      ${baseTypeDefs.type}
+      ${(_d = typeDefs.type) !== null && _d !== void 0 ? _d : ''}
+    `
+    };
+}
+/**
+ *
+ * @param model
+ * @param schemaExtension
+ * @param readOnly
+ * @returns
+ */
+function generateResolvers(ctrl, schemaExtension = {}, readOnly) {
+    const modelName = getModelName(ctrl.model, schemaExtension);
+    const methods = getMethodNames(modelName);
+    const subscriptions = getSubscriptionNames(modelName);
+    const resolvers = { Query: {}, Mutation: {}, Subscription: {} };
+    resolvers.Query[methods.count] = (root, { params }, context) => ctrl.count(params, context);
+    resolvers.Query[methods.list] = (root, { params, fields, pagination }, context) => ctrl.list(params, fields, pagination, context);
+    resolvers.Query[methods.get] = (root, { id }, context) => ctrl.get(id, context);
+    resolvers.Query[methods.findOne] = (root, { params }, context) => ctrl.findOne(params, context);
+    if (!readOnly) {
+        resolvers.Mutation[methods.create] = (root, { item }, context) => appendSubscription(() => ctrl.create(item, context), subscriptions.create.id, subscriptions.create.payload, schemaExtension.subChannelAttr);
+        resolvers.Mutation[methods.update] = (root, { id, item }, context) => appendSubscription(() => ctrl.update(id, item, context), subscriptions.update.id, subscriptions.update.payload, schemaExtension.subChannelAttr);
+        resolvers.Mutation[methods.remove] = (root, { id }, context) => appendSubscription(() => ctrl.remove(id, context), subscriptions.remove.id, subscriptions.remove.payload, schemaExtension.subChannelAttr);
+        resolvers.Mutation[methods.copy] = (root, { id, item }, context) => appendSubscription(() => ctrl.copy(id, item, context), subscriptions.create.id, subscriptions.create.payload, schemaExtension.subChannelAttr);
+        // resolvers.Mutation[methods.create]              = (root, { item }, context)               => model.create(item, context);
+        // resolvers.Mutation[methods.update]              = (root, { id, item }, context)           => model.update(id, item, context);
+        // resolvers.Mutation[methods.remove]              = (root, { id }, context)                 => model.remove(id, context);
+        resolvers.Mutation[methods.addArrayItem] = (root, { id, item }, context) => ctrl.addArrayItem(id, { arrayPath: item.path, item: item.data }, { new: true }, context);
+        resolvers.Mutation[methods.updateArrayItem] = (root, { id, item }, context) => ctrl.updateArrayItem(id, { arrayPath: item.path, arrayFilter: item.filter, updateAttr: item.updateAttr, partial: item.partial, item: item.data }, {}, context);
+        resolvers.Mutation[methods.removeArrayItem] = (root, { id, item }, context) => ctrl.removeArrayItem(id, { arrayPath: item.path, item: item.data }, { new: true }, context);
+        resolvers.Mutation[methods.bulkUpdate] = (root, { ids, items }, context) => ctrl.model.bulkUpdate(ids, items, context);
+        resolvers.Mutation[methods.bulkRemove] = (root, { ids }, context) => ctrl.model.bulkRemove(ids, context);
+        resolvers.Subscription[subscriptions.create.id] = generateSubscription(ctrl.model, subscriptions.create);
+        resolvers.Subscription[subscriptions.update.id] = generateSubscription(ctrl.model, subscriptions.update);
+        resolvers.Subscription[subscriptions.remove.id] = generateSubscription(ctrl.model, subscriptions.remove);
+    }
+    if (!schemaExtension.resolvers)
+        return resolvers;
+    if (schemaExtension.resolvers.Query)
+        Object.assign(resolvers.Query, schemaExtension.resolvers.Query);
+    if (schemaExtension.resolvers.Mutation)
+        Object.assign(resolvers.Mutation, schemaExtension.resolvers.Mutation);
+    if (schemaExtension.resolvers.Subscription)
+        Object.assign(resolvers.Subscription, schemaExtension.resolvers.Subscription);
+    if (schemaExtension.resolvers.Other)
+        Object.assign(resolvers, schemaExtension.resolvers.Other);
+    return resolvers;
+}
+/**
+ *
+ * @param {*} model
+ * @param {*} extension
+ */
+function getModelName(model, extension = {}) {
+    const modelName = extension.modelName || model.modelName || model.name;
+    return modelName[0].toUpperCase() + modelName.slice(1);
+}
+/**
+ *
+ * @param model
+ * @param subscription
+ * @returns
+ */
+function generateSubscription(model, subscription) {
+    if (!(subscription === null || subscription === void 0 ? void 0 : subscription.id))
+        throw new Error('Missing subscription id');
+    let payloadKeys = [];
+    if (subscription.payload)
+        payloadKeys = (0, utils_1.isObject)(subscription.payload) ? Object.values(subscription.payload) : [subscription.payload];
+    payloadKeys.push(subscription.id);
+    return {
+        // include resolve to manipulate payload
+        resolve: (payload_1, _a, context_1) => __awaiter(this, [payload_1, _a, context_1], void 0, function* (payload, { channelId, filter }, context) {
+            if (!payload)
+                return false;
+            for (let pk of payloadKeys) {
+                // if (payload[pk] && model.checkContextPermission(payload[pk], context))
+                //   return payload[pk];//filterObject(payload[pk], filter) || false;
+                if (payload[pk])
+                    return yield model.checkContextPermission(payload[pk], context);
+                return null;
+                //return payload[pk];//filterObject(payload[pk], filter) || false;
+            }
+        }),
+        subscribe: (0, utils_2.getChannelSubscriber)(subscription.id, subscription.payload, model)
+    };
+}
+/**
+ *
+ * @param method
+ * @param subId
+ * @param payload
+ * @param subChannelAttr
+ * @returns
+ */
+function appendSubscription() {
+    return __awaiter(this, arguments, void 0, function* (method = () => Promise.resolve({}), subId, payload, subChannelAttr) {
+        if (!subId || !process.env.GRAPHQL_WS)
+            return method();
+        if (!payload)
+            payload = subId;
+        let promise = method();
+        if (!promise)
+            return Promise.resolve();
+        if (!promise.then)
+            promise = Promise.resolve(promise);
+        const item = yield promise;
+        publishSubData(item, subId, payload, subChannelAttr);
+        return item;
+    });
+}
+/**
+ *
+ * @param item
+ * @param model
+ * @param schemaExtension
+ * @param eventType
+ */
+function publishEventSubData(item, model, schemaExtension = {}, eventType) {
+    const modelName = getModelName(model, schemaExtension);
+    const subscriptions = getSubscriptionNames(modelName);
+    publishSubData(item, subscriptions[eventType].id, subscriptions[eventType].payload, schemaExtension.subChannelAttr);
+}
+exports.publishEventSubData = publishEventSubData;
+/**
+ *
+ * @param item
+ * @param model
+ * @param schemaExtension
+ */
+function publishUpdateSubData(item, model, schemaExtension = {}) {
+    const modelName = getModelName(model, schemaExtension);
+    const subscriptions = getSubscriptionNames(modelName);
+    publishSubData(item, subscriptions.update.id, subscriptions.update.payload, schemaExtension.subChannelAttr);
+}
+exports.publishUpdateSubData = publishUpdateSubData;
+/**
+ *
+ * @param item
+ * @param subId
+ * @param payload
+ * @param subChannelAttr
+ */
+function publishSubData(item, subId, payload, subChannelAttr) {
+    payload !== null && payload !== void 0 ? payload : (payload = subId);
+    const data = {};
+    data[payload] = item;
+    data[payload].nxChannelId = [exports.mainSubChannel];
+    if (item.id)
+        data[payload].nxChannelId.push(item.id.toString());
+    if (subChannelAttr && (subChannelAttr = (0, utils_1.getAttr)(item, subChannelAttr)))
+        data[payload].nxChannelId.push(subChannelAttr.toString());
+    console.log('CHANNEL IDS', data[payload].nxChannelId);
+    utils_2.pubsub.publish(subId, data);
+}
+exports.publishSubData = publishSubData;
+/**
+ *
+ * @param model
+ * @param schemaExtension
+ * @param mergeCodedEntity
+ * @param readOnly
+ */
+function generateSchema(ctrl, schemaExtension = {}, mergeCodedEntity = false, readOnly = false) {
+    const typeDefs = generateTypeDefs(ctrl, schemaExtension, mergeCodedEntity, readOnly);
+    const resolvers = generateResolvers(ctrl, schemaExtension, readOnly);
+    (0, loader_1.loadSchema)({ typeDefs, resolvers });
+}
+exports.generateSchema = generateSchema;

package/build/common/graphql/index.d.ts

@@ -0,0 +1,4 @@
+export * from './directives';
+export * from './loader';
+export * from './generator';
+export * from './utils';

package/build/common/graphql/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./directives"), exports);
+__exportStar(require("./loader"), exports);
+__exportStar(require("./generator"), exports);
+__exportStar(require("./utils"), exports);
+//export * from './scalars';

package/build/common/graphql/interfaces.d.ts

@@ -0,0 +1,67 @@
+import { GraphQLFieldResolver } from 'graphql';
+import { IResolvers } from '@graphql-tools/utils';
+import { NxContext, NxObject, NxTypeObject } from '../interfaces';
+export interface NxGraphQLSchemaTypeDefs {
+    type?: string;
+    query?: string;
+    mutation?: string;
+    subscription?: string;
+}
+export interface NxGraphQLSchemaResolvers extends NxObject {
+    Query?: NxTypeObject<GraphQLFieldResolver<any, NxContext, any, unknown>>;
+    Mutation?: NxTypeObject<GraphQLFieldResolver<any, NxContext, any, unknown>>;
+    Other?: NxTypeObject<any>;
+    Subscription?: NxTypeObject<IResolvers<any, NxContext>>;
+}
+export interface NxGraphQLSchemaDataAttrs {
+    type: string;
+    query: string;
+    input: string;
+}
+export interface NxGraphQLSchemaData {
+    typeDefs?: NxGraphQLSchemaTypeDefs;
+    resolvers?: NxGraphQLSchemaResolvers;
+    fields?: NxGraphQLSchemaDataAttrs;
+}
+export interface NxGraphQLBaseMethodNames {
+    count: string;
+    list: string;
+    get: string;
+    findOne: string;
+    create: string;
+    update: string;
+    remove: string;
+    copy: string;
+    addArrayItem: string;
+    updateArrayItem: string;
+    removeArrayItem: string;
+    bulkUpdate: string;
+    bulkRemove: string;
+}
+export interface NxGraphQLBaseSubscriptionNames {
+    create: {
+        id: string;
+        payload: string;
+    };
+    update: {
+        id: string;
+        payload: string;
+    };
+    remove: {
+        id: string;
+        payload: string;
+    };
+}
+export interface NxGraphQLBaseSubscriptionDef {
+    id: string;
+    payload: string;
+}
+export interface NxGraphQLSchemaExtension extends NxGraphQLSchemaData {
+    modelName?: string;
+    roles?: string | string[] | NxGraphQLSchemaRole;
+    subChannelAttr?: string;
+}
+export interface NxGraphQLSchemaRole {
+    read?: string | string[];
+    write?: string | string[];
+}

package/build/common/graphql/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/common/graphql/loader.d.ts

@@ -0,0 +1,22 @@
+import { GraphQLSchema } from 'graphql';
+import { BaseContext } from '@apollo/server';
+import { NxGraphQLSchemaData } from './interfaces';
+export declare const schemas: never[];
+export declare var mainSchema: NxGraphQLSchemaData;
+/**
+ *
+ * @param data
+ */
+export declare function loadSchema(data: NxGraphQLSchemaData): void;
+/**
+ *
+ * @param {*} directives
+ * @returns
+ */
+export declare function makeSchema(directives?: any[], federation?: boolean): GraphQLSchema;
+/**
+ *
+ * @param {*} directives
+ * @returns
+ */
+export declare function makeApolloConfig(directives?: any[], federation?: boolean): import("@apollo/server").ApolloServerOptionsWithSchema<BaseContext>;

package/build/common/graphql/loader.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeApolloConfig = exports.makeSchema = exports.loadSchema = exports.mainSchema = exports.schemas = void 0;
+const merge_1 = __importDefault(require("lodash/merge"));
+const subgraph_1 = require("@apollo/subgraph");
+const schema_1 = require("@graphql-tools/schema");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const scalars_1 = require("./scalars");
+const types_1 = require("./types");
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+/**
+ *
+ * @param err
+ * @returns
+ */
+let getOriginalError = function (err) {
+    if (!err.originalError)
+        return new Error();
+    if (err.originalError.extensions && Object.keys(err.originalError.extensions).length)
+        return err.originalError;
+    // if (!err.originalError.errors || !err.originalError.errors[0] || !err.originalError.errors[0].originalError)
+    //   return {};
+    // let originalError = err.originalError.errors[0].originalError;
+    // if (!originalError.extensions)
+    //   originalError.extensions = {};
+    return new Error();
+};
+exports.schemas = [];
+exports.mainSchema = {
+    typeDefs: { query: '', mutation: '', subscription: '', type: `${scalars_1.scalarsSchema.typeDefs} ${types_1.typesSchema.typeDefs}` },
+    resolvers: scalars_1.scalarsSchema.resolvers
+};
+/**
+ *
+ * @param data
+ */
+function loadSchema(data) {
+    var _a, _b, _c, _d;
+    if ((_a = data.typeDefs) === null || _a === void 0 ? void 0 : _a.query)
+        exports.mainSchema.typeDefs.query += data.typeDefs.query;
+    if ((_b = data.typeDefs) === null || _b === void 0 ? void 0 : _b.mutation)
+        exports.mainSchema.typeDefs.mutation += data.typeDefs.mutation;
+    if ((_c = data.typeDefs) === null || _c === void 0 ? void 0 : _c.subscription)
+        exports.mainSchema.typeDefs.subscription += data.typeDefs.subscription;
+    if ((_d = data.typeDefs) === null || _d === void 0 ? void 0 : _d.type)
+        exports.mainSchema.typeDefs.type += data.typeDefs.type;
+    exports.mainSchema.resolvers = (0, merge_1.default)(exports.mainSchema.resolvers, data.resolvers);
+}
+exports.loadSchema = loadSchema;
+/**
+ *
+ * @param {*} directives
+ * @returns
+ */
+function makeSchema(directives = [], federation = false) {
+    var _a, _b, _c;
+    if (!exports.mainSchema.typeDefs || !exports.mainSchema.resolvers)
+        throw new Error('GraphQL schema addDirectives: missing schema typeDefs or resolvers');
+    let subscription = '';
+    let query = '';
+    let mutation = '';
+    exports.mainSchema.typeDefs.query = ((_a = exports.mainSchema.typeDefs.query) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+    exports.mainSchema.typeDefs.mutation = ((_b = exports.mainSchema.typeDefs.mutation) === null || _b === void 0 ? void 0 : _b.trim()) || '';
+    exports.mainSchema.typeDefs.subscription = ((_c = exports.mainSchema.typeDefs.subscription) === null || _c === void 0 ? void 0 : _c.trim()) || '';
+    if (exports.mainSchema.typeDefs.query)
+        query = `type Query { ${exports.mainSchema.typeDefs.query} }`;
+    else {
+        query = `type Query { helloWorld: String }`;
+        exports.mainSchema.resolvers.Query = { helloWorld: () => 'Hello NxFrame' };
+    }
+    if (exports.mainSchema.typeDefs.mutation)
+        mutation = `type Mutation { ${exports.mainSchema.typeDefs.mutation} }`;
+    else
+        delete exports.mainSchema.resolvers.Mutation;
+    if (exports.mainSchema.typeDefs.subscription)
+        subscription = `type Subscription { ${exports.mainSchema.typeDefs.subscription} }`;
+    else
+        delete exports.mainSchema.resolvers.Subscription;
+    let schema;
+    if (!federation) {
+        schema = (0, schema_1.makeExecutableSchema)({
+            typeDefs: [
+                ...directives.map(d => d.typeDefs),
+                `
+        ${query}
+        ${mutation}
+        ${subscription}
+        ${exports.mainSchema.typeDefs.type}
+      `
+            ],
+            resolvers: exports.mainSchema.resolvers
+        });
+    }
+    else {
+        let schemaString = `
+        extend schema @link(url: "https://specs.apollo.dev/federation/v2.7", import: ["@key", "@shareable"])
+        ${query}
+        ${mutation}
+        ${subscription}
+        ${exports.mainSchema.typeDefs.type}
+      `;
+        schema = (0, subgraph_1.buildSubgraphSchema)({
+            typeDefs: [
+                ...directives.map(d => (0, graphql_tag_1.default)(d.typeDefs)),
+                (0, graphql_tag_1.default)(schemaString)
+            ],
+            resolvers: exports.mainSchema.resolvers
+        });
+    }
+    // apply directives transform method to actual schema
+    directives.forEach(d => {
+        constants_1.APP.logger.info(`Adding ${d.name || ''} directive`);
+        if (!d.transformer) {
+            constants_1.APP.logger.warn(`Missing ${d.name || ''} directive transformer`);
+            return;
+        }
+        schema = d.transformer(schema);
+    });
+    return schema;
+}
+exports.makeSchema = makeSchema;
+/**
+ *
+ * @param {*} directives
+ * @returns
+ */
+function makeApolloConfig(directives = [], federation = false) {
+    const config = {
+        schema: makeSchema(directives, federation),
+        // context: ({ req, connection, payload }: any) => {
+        //   // manage graphql api request
+        //   if (req) {
+        //     return {
+        //       user         : req.auth && req.auth.user,
+        //       userType     : req.auth && req.auth.iss,
+        //       access       : req.auth && req.auth.jti,
+        //       remoteAddress: req.connection.remoteAddress,
+        //       userAgent    : req.headers['user-agent']
+        //     };
+        //   }
+        //   // manage graphql ws request
+        //   return connection && connection.context || {};
+        // },
+        formatError: (err) => {
+            const errExtensions = err.extensions && !!Object.keys(err.extensions).length;
+            const error = {
+                message: err.message,
+                extensions: errExtensions ? err.extensions : getOriginalError(err).extensions,
+                locations: err.locations,
+                path: err.path
+            };
+            if ((0, utils_1.prodMode)()) {
+                const exceptionName = (0, utils_1.getAttr)(error, 'extensions.exception.name');
+                const extensionCode = (0, utils_1.getAttr)(error, 'extensions.code');
+                if (exceptionName === 'MongoError') {
+                    error.message = 'errors.internalError';
+                    delete error.extensions.exception;
+                }
+                switch (extensionCode) {
+                    case 'INTERNAL_SERVER_ERROR':
+                        const message = error.message.toLowerCase();
+                        if (message.includes('duplicate key'))
+                            error.message = 'errors.duplicateKey';
+                        else
+                            error.message = 'errors.internalError';
+                        break;
+                    case 'BAD_USER_INPUT':
+                        error.message = 'errors.badUserInput';
+                        break;
+                    default:
+                        break;
+                }
+                delete error.extensions.stacktrace;
+                error.message = error.message.replace(/(Cannot query field).*$/i, "$1")
+                    .replace(/(Unknown operation).*$/i, "$1");
+            }
+            return error;
+        }
+    };
+    return config;
+}
+exports.makeApolloConfig = makeApolloConfig;