@nextage/nx-frame-be 1.0.1

package/build/common/graphql/directives.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authDirective = exports.getUser = exports.createAuthDirective = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const errors_1 = require("../errors");
+const errors_2 = require("../errors");
+function createAuthDirective(directiveName, getUserFn) {
+    const typeDirectiveArgumentMaps = {};
+    return {
+        name: directiveName,
+        typeDefs: `directive @${directiveName}(requires: String = "") on OBJECT | FIELD_DEFINITION`,
+        transformer: (schema) => {
+            return (0, utils_1.mapSchema)(schema, {
+                [utils_1.MapperKind.TYPE]: type => {
+                    const authDirective = ((0, utils_1.getDirective)(schema, type, directiveName) || [])[0];
+                    if (authDirective)
+                        typeDirectiveArgumentMaps[type.name] = authDirective;
+                    return undefined;
+                },
+                [utils_1.MapperKind.OBJECT_FIELD]: (fieldConfig, _fieldName, typeName) => {
+                    const authDirective = ((0, utils_1.getDirective)(schema, fieldConfig, directiveName) || [])[0] || typeDirectiveArgumentMaps[typeName];
+                    if (!authDirective)
+                        return;
+                    const { requires } = authDirective;
+                    const { resolve = graphql_1.defaultFieldResolver } = fieldConfig;
+                    fieldConfig.resolve = function (source, args, context, info) {
+                        const user = getUserFn(context); // getUserFn(context.headers.authToken);
+                        if (!user || !user.id)
+                            throw new errors_1.AuthenticationError('messages.authentication.required');
+                        // if (user.err)
+                        //   throw new AuthenticationError('messages.authentication.required');
+                        // user exists but is not active
+                        if (!user.active)
+                            throw new errors_1.AuthenticationError('messages.authentication.required');
+                        if (requires && !user.hasRole(requires.split(',')))
+                            throw new errors_2.ForbiddenError('messages.authorization.missingRole');
+                        return resolve(source, args, context, info);
+                    };
+                    return fieldConfig;
+                }
+            });
+        }
+    };
+}
+exports.createAuthDirective = createAuthDirective;
+/**
+ *
+ * @param {*} context
+ * @returns
+ */
+function getUser(context) {
+    return context.user || null;
+}
+exports.getUser = getUser;
+exports.authDirective = createAuthDirective('auth', getUser);

package/build/common/graphql/generator copy.d.ts

@@ -0,0 +1,41 @@
+import { BaseModel } from '../base/base.model';
+import { NxGraphQLBaseSubscriptionNames, NxGraphQLSchemaDataAttrs } from './interfaces';
+import { NxGraphQLSchemaExtension } from './interfaces';
+export declare const codedEntityFields: NxGraphQLSchemaDataAttrs;
+export declare const foldedEntityFields: {
+    type: string;
+    query: string;
+    input: string;
+};
+export declare const mainSubChannel = "mainCH";
+/**
+ *
+ * @param item
+ * @param model
+ * @param schemaExtension
+ * @param eventType
+ */
+export declare function publishEventSubData(item: any, model: BaseModel<any, any, any>, schemaExtension: NxGraphQLSchemaExtension | undefined, eventType: keyof NxGraphQLBaseSubscriptionNames): void;
+/**
+ *
+ * @param item
+ * @param model
+ * @param schemaExtension
+ */
+export declare function publishUpdateSubData(item: any, model: BaseModel<any, any, any>, schemaExtension?: NxGraphQLSchemaExtension): void;
+/**
+ *
+ * @param item
+ * @param subId
+ * @param payload
+ * @param subChannelAttr
+ */
+export declare function publishSubData(item: any, subId: string, payload?: string, subChannelAttr?: string): void;
+/**
+ *
+ * @param model
+ * @param schemaExtension
+ * @param mergeCodedEntity
+ * @param readOnly
+ */
+export declare function generateSchema<T extends BaseModel<any, any, any>>(model: T, schemaExtension?: NxGraphQLSchemaExtension, mergeCodedEntity?: boolean, readOnly?: boolean): void;

package/build/common/graphql/generator copy.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(model, schemaExtension = {}, mergeCodedEntity, readOnly) {
+    const modelName = getModelName(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!)                                              : String! @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}
+      ${typeDefs.query || ''}
+    `,
+        mutation: `
+      ${readOnly ? '' : baseTypeDefs.mutation}
+      ${typeDefs.mutation || ''}
+    `,
+        subscription: `
+      ${readOnly ? '' : baseTypeDefs.subscription}
+      ${typeDefs.subscription || ''}
+    `,
+        type: `
+      ${baseTypeDefs.type}
+      ${typeDefs.type || ''}
+    `
+    };
+}
+/**
+ *
+ * @param model
+ * @param schemaExtension
+ * @param readOnly
+ * @returns
+ */
+function generateResolvers(model, schemaExtension = {}, readOnly) {
+    const modelName = getModelName(model, schemaExtension);
+    const methods = getMethodNames(modelName);
+    const subscriptions = getSubscriptionNames(modelName);
+    const resolvers = { Query: {}, Mutation: {}, Subscription: {} };
+    resolvers.Query[methods.count] = (root, { params }, context) => model.count(params, context);
+    resolvers.Query[methods.list] = (root, { params, fields, pagination }, context) => model.list(params, fields, pagination, context);
+    resolvers.Query[methods.get] = (root, { id }, context) => model.get(id, context);
+    resolvers.Query[methods.findOne] = (root, { params }, context) => model.findOne(params, context);
+    if (!readOnly) {
+        resolvers.Mutation[methods.create] = (root, { item }, context) => appendSubscription(() => model.create(item, context), subscriptions.create.id, subscriptions.create.payload, schemaExtension.subChannelAttr);
+        resolvers.Mutation[methods.update] = (root, { id, item }, context) => appendSubscription(() => model.update(id, item, context), subscriptions.update.id, subscriptions.update.payload, schemaExtension.subChannelAttr);
+        resolvers.Mutation[methods.remove] = (root, { id }, context) => appendSubscription(() => model.remove(id, context), subscriptions.remove.id, subscriptions.remove.payload, schemaExtension.subChannelAttr);
+        resolvers.Mutation[methods.copy] = (root, { id, item }, context) => appendSubscription(() => model.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) => model.addArrayItem(id, { arrayPath: item.path, item: item.data }, { new: true }, context);
+        resolvers.Mutation[methods.updateArrayItem] = (root, { id, item }, context) => model.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) => model.removeArrayItem(id, { arrayPath: item.path, item: item.data }, { new: true }, context);
+        resolvers.Mutation[methods.bulkUpdate] = (root, { ids, items }, context) => model.bulkUpdate(ids, items, context);
+        resolvers.Mutation[methods.bulkRemove] = (root, { ids }, context) => model.bulkRemove(ids, context);
+        resolvers.Subscription[subscriptions.create.id] = generateSubscription(model, subscriptions.create);
+        resolvers.Subscription[subscriptions.update.id] = generateSubscription(model, subscriptions.update);
+        resolvers.Subscription[subscriptions.remove.id] = generateSubscription(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) {
+    if (!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(model, schemaExtension = {}, mergeCodedEntity = false, readOnly = false) {
+    const typeDefs = generateTypeDefs(model, schemaExtension, mergeCodedEntity, readOnly);
+    const resolvers = generateResolvers(model, schemaExtension, readOnly);
+    (0, loader_1.loadSchema)({ typeDefs, resolvers });
+}
+exports.generateSchema = generateSchema;

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

@@ -0,0 +1,42 @@
+import { BaseModel } from '../base/base.model';
+import { BaseController } from '../base/base.controller';
+import { NxGraphQLBaseSubscriptionNames, NxGraphQLSchemaDataAttrs } from './interfaces';
+import { NxGraphQLSchemaExtension } from './interfaces';
+export declare const codedEntityFields: NxGraphQLSchemaDataAttrs;
+export declare const foldedEntityFields: {
+    type: string;
+    query: string;
+    input: string;
+};
+export declare const mainSubChannel = "mainCH";
+/**
+ *
+ * @param item
+ * @param model
+ * @param schemaExtension
+ * @param eventType
+ */
+export declare function publishEventSubData(item: any, model: BaseModel<any, any, any>, schemaExtension: NxGraphQLSchemaExtension | undefined, eventType: keyof NxGraphQLBaseSubscriptionNames): void;
+/**
+ *
+ * @param item
+ * @param model
+ * @param schemaExtension
+ */
+export declare function publishUpdateSubData(item: any, model: BaseModel<any, any, any>, schemaExtension?: NxGraphQLSchemaExtension): void;
+/**
+ *
+ * @param item
+ * @param subId
+ * @param payload
+ * @param subChannelAttr
+ */
+export declare function publishSubData(item: any, subId: string, payload?: string, subChannelAttr?: string): void;
+/**
+ *
+ * @param model
+ * @param schemaExtension
+ * @param mergeCodedEntity
+ * @param readOnly
+ */
+export declare function generateSchema<T extends BaseController<any, any, any>>(ctrl: T, schemaExtension?: NxGraphQLSchemaExtension, mergeCodedEntity?: boolean, readOnly?: boolean): void;