@nextage/nx-frame-be 1.0.1

package/build/common/errors.d.ts

@@ -0,0 +1,13 @@
+import { NxObject } from './interfaces';
+export declare class AuthenticationError extends Error {
+    extensions: NxObject;
+    constructor(message?: string, i18n?: string);
+}
+export declare class ForbiddenError extends Error {
+    extensions: NxObject;
+    constructor(message?: string, i18n?: string);
+}
+export declare class AppError extends Error {
+    extensions: NxObject;
+    constructor(message?: string, i18n?: string);
+}

package/build/common/errors.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppError = exports.ForbiddenError = exports.AuthenticationError = void 0;
+class AuthenticationError extends Error {
+    constructor(message = 'Authentication required', i18n = 'messages.authentication.required') {
+        super(message);
+        this.extensions = { code: 401, i18n };
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class ForbiddenError extends Error {
+    constructor(message = 'Forbidden', i18n = 'messages.authorization.accessDenied') {
+        super(message);
+        this.extensions = { code: 403, i18n };
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class AppError extends Error {
+    constructor(message = 'Application Error', i18n) {
+        super(message);
+        this.extensions = { code: 'APP_ERROR', i18n };
+    }
+}
+exports.AppError = AppError;

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

@@ -0,0 +1,20 @@
+import { JwtPayload } from 'jsonwebtoken';
+import { Request } from 'express';
+import { UserDoc } from '../models/user.model';
+export interface ErrorResponse extends Error {
+    status?: number;
+}
+export interface ExpressErrorResult {
+    result: {
+        fields: string[];
+        code: number;
+        message: string;
+    };
+}
+export interface AuthRequest extends Request {
+    auth?: AuthRequestContext;
+}
+export interface AuthRequestContext extends JwtPayload {
+    user?: UserDoc | null;
+    err?: ErrorResponse;
+}

package/build/common/express/express.interfaces.js

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

package/build/common/express/express.utils.d.ts

@@ -0,0 +1,31 @@
+import { Request, Response, NextFunction, Handler } from 'express';
+import { ValidationError, Result, Schema } from 'express-validator';
+import { DefaultSchemaKeys } from 'express-validator/lib/middlewares/schema';
+import { ExpressErrorResult } from './express.interfaces';
+/**
+ *
+ * @param schema
+ * @param errorFormatter
+ * @returns
+ */
+export declare function validateSchema(schema: Schema<DefaultSchemaKeys>, errorFormatter?: (err: Result<ValidationError>, req: Request) => ExpressErrorResult | Result<ValidationError>): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/**
+ *
+ * @param {*} res
+ * @param {*} status
+ * @param {*} content
+ * @returns
+ */
+export declare function sendJSONResponse(res: Response, status?: number, content?: Object): void;
+/**
+ * Create an Express middleware function which errors if an HTTP method is not allowed.
+ *
+ * @access public
+ * @param {Array<string>} [methods=[]]
+ *     The HTTP methods which will not throw 405 errors.
+ * @param {string} [message]
+ *     The error message text to use if a disallowed method is used.
+ * @returns {import('express').Handler}
+ *     Returns a middleware function.
+ */
+export declare function allowMethods(methods?: string[], message?: string): Handler;

package/build/common/express/express.utils.js

@@ -0,0 +1,85 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowMethods = exports.sendJSONResponse = exports.validateSchema = void 0;
+const http_errors_1 = __importDefault(require("http-errors"));
+const express_validator_1 = require("express-validator");
+/**
+ *
+ * @param schema
+ * @param errorFormatter
+ * @returns
+ */
+function validateSchema(schema, errorFormatter = (err, req) => err) {
+    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+        yield (0, express_validator_1.checkSchema)(schema).run(req);
+        const errors = (0, express_validator_1.validationResult)(req);
+        if (errors.isEmpty())
+            return next();
+        res.status(400).json(errorFormatter(errors, req));
+    });
+}
+exports.validateSchema = validateSchema;
+/**
+ *
+ * @param {*} res
+ * @param {*} status
+ * @param {*} content
+ * @returns
+ */
+function sendJSONResponse(res, status = 200, content = {}) {
+    if (!res)
+        return;
+    res.status(status);
+    res.json(content);
+}
+exports.sendJSONResponse = sendJSONResponse;
+/**
+ * Create an Express middleware function which errors if an HTTP method is not allowed.
+ *
+ * @access public
+ * @param {Array<string>} [methods=[]]
+ *     The HTTP methods which will not throw 405 errors.
+ * @param {string} [message]
+ *     The error message text to use if a disallowed method is used.
+ * @returns {import('express').Handler}
+ *     Returns a middleware function.
+ */
+function allowMethods(methods = [], message = 'Method Not Allowed') {
+    const normalizedMethods = normalizeAllowedMethods(methods);
+    return (request, response, next) => {
+        if (!normalizedMethods.includes(request.method.toUpperCase())) {
+            response.header('Allow', normalizedMethods.join(', '));
+            return next((0, http_errors_1.default)(405, message));
+        }
+        next();
+    };
+}
+exports.allowMethods = allowMethods;
+;
+/**
+ * Normalise an array of HTTP methods.
+ *
+ * @access private
+ * @param {Array<string>} methods
+ *     The HTTP methods to normalise.
+ * @returns {Array<string>}
+ *     Returns an array of capitalised HTTP methods.
+ */
+function normalizeAllowedMethods(methods) {
+    if (!Array.isArray(methods))
+        return [];
+    return methods.filter(method => typeof method === 'string')
+        .map(method => method.toUpperCase());
+}

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

@@ -0,0 +1,2 @@
+export * from './express.interfaces';
+export * from './express.utils';

package/build/common/express/index.js

@@ -0,0 +1,18 @@
+"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("./express.interfaces"), exports);
+__exportStar(require("./express.utils"), exports);

package/build/common/graphql/__test__/generator.schema.test.d.ts

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

package/build/common/graphql/__test__/generator.schema.test.js

@@ -0,0 +1,391 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const server_1 = require("@apollo/server");
+const graphql_constraint_directive_1 = require("graphql-constraint-directive");
+const coded_entity_model_1 = require("../../models/coded-entity.model");
+const coded_entity_controller_1 = require("../../models/coded-entity.controller");
+const utils_1 = require("../../utils");
+const directives_1 = require("../directives");
+const generator_1 = require("../generator");
+const loader_1 = require("../loader");
+// ensure our server's context is typed correctly
+// create a test server to test against, using our production typeDefs,
+// resolvers, and dataSources.
+let server;
+const roles = { read: 'READ_ROLE', write: 'WRITE_ROLE' };
+beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+    const params = {
+        fields: {
+            type: `
+        id  : String
+        code: String
+        name: String
+        data: JSON
+      `,
+            query: `
+        code: String
+        name: String
+      `,
+            input: `
+        code: String
+        name: String
+        data: JSON
+      `
+        },
+        roles: { write: roles.write }
+    };
+    // generateSchema<CodedEntity>(ceModel, params);
+    (0, generator_1.generateSchema)(coded_entity_controller_1.ceCtrl, params);
+    const constraintDir = { name: 'constraint', typeDefs: graphql_constraint_directive_1.constraintDirectiveTypeDefs, transformer: (0, graphql_constraint_directive_1.constraintDirective)() };
+    const config = (0, loader_1.makeApolloConfig)([directives_1.authDirective, constraintDir]);
+    server = new server_1.ApolloServer(config);
+}));
+afterAll(() => __awaiter(void 0, void 0, void 0, function* () {
+    server === null || server === void 0 ? void 0 : server.stop();
+}));
+const createItem = () => __awaiter(void 0, void 0, void 0, function* () {
+    const item = {
+        code: (0, utils_1.uuid)(),
+        name: 'Test',
+        data: {
+            items: [
+                { id: (0, utils_1.uuid)(), value: Math.random() },
+                { id: (0, utils_1.uuid)(), value: Math.random() },
+                { id: (0, utils_1.uuid)(), value: Math.random() }
+            ]
+        }
+    };
+    const ceItem = yield (coded_entity_model_1.ceModel === null || coded_entity_model_1.ceModel === void 0 ? void 0 : coded_entity_model_1.ceModel.create(item, {}));
+    return { ceItem, item };
+});
+it('returns an error if not authenticated (count', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const response = yield server.executeOperation({
+        query: 'query codedEntityCount($params: CodedEntityQuery) { codedEntityCount(params: $params) }',
+        variables: { params: {} }
+    });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authentication.required');
+    expect((_a = response.body.singleResult.errors[0].extensions) === null || _a === void 0 ? void 0 : _a.code).toEqual(401);
+}));
+it('returns an error if not authenticated (list)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
+    //const { ceItem: ce1 } = await createItem();
+    const response = yield server.executeOperation({
+        query: 'query codedEntityList($params: CodedEntityQuery) { codedEntityList(params: $params) { id code name } }',
+        variables: { params: {} }
+    });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authentication.required');
+    expect((_b = response.body.singleResult.errors[0].extensions) === null || _b === void 0 ? void 0 : _b.code).toEqual(401);
+}));
+it('returns an error if not authenticated (get)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _c;
+    const { ceItem: ce1 } = yield createItem();
+    const response = yield server.executeOperation({
+        query: 'query codedEntity($id: ID!) { codedEntity(id: $id) { id code name data } }',
+        variables: { id: ce1.id }
+    });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authentication.required');
+    expect((_c = response.body.singleResult.errors[0].extensions) === null || _c === void 0 ? void 0 : _c.code).toEqual(401);
+}));
+it('returns an error if not authenticated (findOne)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _d;
+    //const { ceItem: ce1 } = await createItem();
+    const response = yield server.executeOperation({
+        query: 'query findOneCodedEntity($params: CodedEntityQuery) { findOneCodedEntity(params: $params) { id code name } }',
+        variables: { params: {} }
+    });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authentication.required');
+    expect((_d = response.body.singleResult.errors[0].extensions) === null || _d === void 0 ? void 0 : _d.code).toEqual(401);
+}));
+it('returns an error if missing role (create)', () => __awaiter(void 0, void 0, void 0, function* () {
+    //const { ceItem: ce1 } = await createItem();
+    var _e;
+    const item = {
+        code: (0, utils_1.uuid)(),
+        name: 'Test',
+        data: { items: [] }
+    };
+    const response = yield server.executeOperation({
+        query: 'mutation createCodedEntity($item: CodedEntityInput!) { createCodedEntity(item: $item) { id code name } }',
+        variables: { item }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authorization.missingRole');
+    expect((_e = response.body.singleResult.errors[0].extensions) === null || _e === void 0 ? void 0 : _e.code).toEqual(403);
+}));
+it('returns an error if missing role (update)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _f;
+    const { ceItem: ce1 } = yield createItem();
+    const updatedName = `${ce1.name}_updated`;
+    const response = yield server.executeOperation({
+        query: 'mutation updateCodedEntity($id: ID!, $item: CodedEntityInput!) { updateCodedEntity(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item: { name: updatedName } }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authorization.missingRole');
+    expect((_f = response.body.singleResult.errors[0].extensions) === null || _f === void 0 ? void 0 : _f.code).toEqual(403);
+}));
+it('returns an error if missing role (copy)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _g;
+    const { ceItem: ce1 } = yield createItem();
+    const updatedName = `${ce1.name}_updated`;
+    const response = yield server.executeOperation({
+        query: 'mutation copyCodedEntity($id: ID!, $item: CodedEntityInput!) { copyCodedEntity(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item: { name: updatedName } }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authorization.missingRole');
+    expect((_g = response.body.singleResult.errors[0].extensions) === null || _g === void 0 ? void 0 : _g.code).toEqual(403);
+}));
+it('returns an error if missing role (remove)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _h;
+    const { ceItem: ce1 } = yield createItem();
+    const response = yield server.executeOperation({
+        query: 'mutation removeCodedEntity($id: ID!) { removeCodedEntity(id: $id) { id } }',
+        variables: { id: ce1.id }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authorization.missingRole');
+    expect((_h = response.body.singleResult.errors[0].extensions) === null || _h === void 0 ? void 0 : _h.code).toEqual(403);
+}));
+it('returns an error if missing role (addArrayItem)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _j;
+    const { ceItem: ce1 } = yield createItem();
+    const item = { path: 'data.items', data: { id: (0, utils_1.uuid)() } };
+    const response = yield server.executeOperation({
+        query: 'mutation addCodedEntityArrayItem($id: ID!, $item: AddArrayElemItem!) { addCodedEntityArrayItem(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authorization.missingRole');
+    expect((_j = response.body.singleResult.errors[0].extensions) === null || _j === void 0 ? void 0 : _j.code).toEqual(403);
+}));
+it('returns an error if missing role (updateArrayItem)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _k;
+    const { ceItem: ce1 } = yield createItem();
+    const item = { path: 'data.items', filter: { id: ce1.data.items[1].id }, data: { id: ce1.data.items[1].id, value: 1000 } };
+    const response = yield server.executeOperation({
+        query: 'mutation updateCodedEntityArrayItem($id: ID!, $item: UpdateArrayElemItem!) { updateCodedEntityArrayItem(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authorization.missingRole');
+    expect((_k = response.body.singleResult.errors[0].extensions) === null || _k === void 0 ? void 0 : _k.code).toEqual(403);
+}));
+it('returns an error if missing role (removeArrayItem)', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _l;
+    const { ceItem: ce1 } = yield createItem();
+    const item = { path: 'data.items', data: { id: (0, utils_1.uuid)() } };
+    const response = yield server.executeOperation({
+        query: 'mutation removeCodedEntityArrayItem($id: ID!, $item: RemoveArrayElemItem!) { removeCodedEntityArrayItem(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeDefined();
+    expect(response.body.singleResult.errors[0].message).toEqual('messages.authorization.missingRole');
+    expect((_l = response.body.singleResult.errors[0].extensions) === null || _l === void 0 ? void 0 : _l.code).toEqual(403);
+}));
+it('queries GraphQL to get a list of items', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _m, _o, _p, _q, _r;
+    const { ceItem: ce1 } = yield createItem();
+    const { ceItem: ce2 } = yield createItem();
+    const { ceItem: ce3 } = yield createItem();
+    const response = yield server.executeOperation({
+        query: 'query codedEntityList($params: CodedEntityQuery) { codedEntityList(params: $params) { id code name } }',
+        variables: { params: {} }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect((_o = (_m = response.body.singleResult.data) === null || _m === void 0 ? void 0 : _m.codedEntityList) === null || _o === void 0 ? void 0 : _o.length).toEqual(3);
+    expect((_p = response.body.singleResult.data) === null || _p === void 0 ? void 0 : _p.codedEntityList[0].code).toEqual(ce1.code);
+    expect((_q = response.body.singleResult.data) === null || _q === void 0 ? void 0 : _q.codedEntityList[1].code).toEqual(ce2.code);
+    expect((_r = response.body.singleResult.data) === null || _r === void 0 ? void 0 : _r.codedEntityList[2].code).toEqual(ce3.code);
+}));
+it('queries GraphQL to get items count', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _s;
+    yield createItem();
+    yield createItem();
+    yield createItem();
+    const response = yield server.executeOperation({
+        query: 'query codedEntityCount($params: CodedEntityQuery) { codedEntityCount(params: $params) }',
+        variables: { params: {} }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect((_s = response.body.singleResult.data) === null || _s === void 0 ? void 0 : _s.codedEntityCount).toEqual(3);
+}));
+it('queries GraphQL to get one item by id', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _t, _u, _v, _w, _x;
+    const { ceItem: ce1 } = yield createItem();
+    const response = yield server.executeOperation({
+        query: 'query codedEntity($id: ID!) { codedEntity(id: $id) { id code name data } }',
+        variables: { id: ce1.id }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect((_t = response.body.singleResult.data) === null || _t === void 0 ? void 0 : _t.codedEntity).toBeDefined();
+    expect((_u = response.body.singleResult.data) === null || _u === void 0 ? void 0 : _u.codedEntity.id).toEqual(ce1.id);
+    expect((_v = response.body.singleResult.data) === null || _v === void 0 ? void 0 : _v.codedEntity.code).toEqual(ce1.code);
+    expect((_w = response.body.singleResult.data) === null || _w === void 0 ? void 0 : _w.codedEntity.name).toEqual(ce1.name);
+    expect((_x = response.body.singleResult.data) === null || _x === void 0 ? void 0 : _x.codedEntity.data).toEqual(ce1.data);
+}));
+it('queries GraphQL to get one item by filter', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _y, _z, _0, _1, _2;
+    const { ceItem: ce1 } = yield createItem();
+    const response = yield server.executeOperation({
+        query: 'query findOneCodedEntity($params: CodedEntityQuery) { findOneCodedEntity(params: $params) { id code name data } }',
+        variables: { params: {} }
+    }, { contextValue: global.getContext() });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect((_y = response.body.singleResult.data) === null || _y === void 0 ? void 0 : _y.findOneCodedEntity).toBeDefined();
+    expect((_z = response.body.singleResult.data) === null || _z === void 0 ? void 0 : _z.findOneCodedEntity.id).toEqual(ce1.id);
+    expect((_0 = response.body.singleResult.data) === null || _0 === void 0 ? void 0 : _0.findOneCodedEntity.code).toEqual(ce1.code);
+    expect((_1 = response.body.singleResult.data) === null || _1 === void 0 ? void 0 : _1.findOneCodedEntity.name).toEqual(ce1.name);
+    expect((_2 = response.body.singleResult.data) === null || _2 === void 0 ? void 0 : _2.findOneCodedEntity.data).toEqual(ce1.data);
+}));
+it('queries GraphQL to get create a new item', () => __awaiter(void 0, void 0, void 0, function* () {
+    const item = {
+        code: (0, utils_1.uuid)(),
+        name: 'Test',
+        data: { items: [{ id: (0, utils_1.uuid)() }] }
+    };
+    const response = yield server.executeOperation({
+        query: 'mutation createCodedEntity($item: CodedEntityInput!) { createCodedEntity(item: $item) { id code name data } }',
+        variables: { item }
+    }, 
+    // write permission in needed for this test
+    { contextValue: global.getContext([roles.write]) });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data).toBeDefined();
+    expect(response.body.singleResult.data.createCodedEntity).toBeDefined();
+    expect(response.body.singleResult.data.createCodedEntity.id).toBeDefined();
+    expect(response.body.singleResult.data.createCodedEntity.code).toEqual(item.code);
+    expect(response.body.singleResult.data.createCodedEntity.name).toEqual(item.name);
+    expect(response.body.singleResult.data.createCodedEntity.data).toEqual(item.data);
+}));
+it('queries GraphQL to get update one item', () => __awaiter(void 0, void 0, void 0, function* () {
+    const { ceItem: ce1 } = yield createItem();
+    const updatedName = `${ce1.name}_updated`;
+    const response = yield server.executeOperation({
+        query: 'mutation updateCodedEntity($id: ID!, $item: CodedEntityInput!) { updateCodedEntity(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item: { name: updatedName } }
+    }, { contextValue: global.getContext([roles.write]) });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data).toBeDefined();
+    expect(response.body.singleResult.data.updateCodedEntity).toBeDefined();
+    expect(response.body.singleResult.data.updateCodedEntity.id).toEqual(ce1.id);
+    expect(response.body.singleResult.data.updateCodedEntity.code).toEqual(ce1.code);
+    expect(response.body.singleResult.data.updateCodedEntity.name).toEqual(updatedName);
+    expect(response.body.singleResult.data.updateCodedEntity.data).toEqual(ce1.data);
+}));
+it('queries GraphQL to copy one item', () => __awaiter(void 0, void 0, void 0, function* () {
+    const { ceItem: ce1 } = yield createItem();
+    const updatedName = `${ce1.name}_updated`;
+    const response = yield server.executeOperation({
+        query: 'mutation copyCodedEntity($id: ID!, $item: CodedEntityInput!) { copyCodedEntity(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item: { name: updatedName } }
+    }, { contextValue: global.getContext([roles.write]) });
+    const ceList = yield coded_entity_model_1.ceModel.list();
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data).toBeDefined();
+    expect(response.body.singleResult.data.copyCodedEntity).toBeDefined();
+    expect(response.body.singleResult.data.copyCodedEntity.id).not.toEqual(ce1.id);
+    expect(response.body.singleResult.data.copyCodedEntity.code).toEqual(ce1.code);
+    expect(response.body.singleResult.data.copyCodedEntity.name).toEqual(updatedName);
+    expect(response.body.singleResult.data.copyCodedEntity.data).toEqual(ce1.data);
+    expect(ceList.length).toEqual(2);
+    expect(ceList[0].id).toEqual(ce1.id);
+    expect(ceList[1].id).toContain(response.body.singleResult.data.copyCodedEntity.id);
+}));
+it('queries GraphQL to get remove one item', () => __awaiter(void 0, void 0, void 0, function* () {
+    const { ceItem: ce1 } = yield createItem();
+    const response = yield server.executeOperation({
+        query: 'mutation removeCodedEntity($id: ID!) { removeCodedEntity(id: $id) { id } }',
+        variables: { id: ce1.id }
+    }, { contextValue: global.getContext([roles.write]) });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data).toBeDefined();
+    expect(response.body.singleResult.data.removeCodedEntity).toBeDefined();
+    expect(response.body.singleResult.data.removeCodedEntity).toEqual({ id: ce1.id });
+    const ce = yield coded_entity_model_1.ceModel.get(ce1.id, {});
+    expect(ce).toBeNull();
+}));
+it('queries GraphQL to add one array element inside one item', () => __awaiter(void 0, void 0, void 0, function* () {
+    const { ceItem: ce1 } = yield createItem();
+    const item = { path: 'data.items', data: { id: (0, utils_1.uuid)() } };
+    const response = yield server.executeOperation({
+        query: 'mutation addCodedEntityArrayItem($id: ID!, $item: AddArrayElemItem!) { addCodedEntityArrayItem(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item }
+    }, { contextValue: global.getContext([roles.write]) });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data).toBeDefined();
+    expect(response.body.singleResult.data.addCodedEntityArrayItem).toBeDefined();
+    expect(response.body.singleResult.data.addCodedEntityArrayItem.data.items.length).toEqual(ce1.data.items.length + 1);
+    expect(response.body.singleResult.data.addCodedEntityArrayItem.data.items[ce1.data.items.length].id).toEqual(item.data.id);
+}));
+it('queries GraphQL to update one array element inside one item', () => __awaiter(void 0, void 0, void 0, function* () {
+    const { ceItem: ce1 } = yield createItem();
+    const item = { path: 'data.items', filter: { id: ce1.data.items[1].id }, data: { id: ce1.data.items[1].id, value: 1000 } };
+    const response = yield server.executeOperation({
+        query: 'mutation updateCodedEntityArrayItem($id: ID!, $item: UpdateArrayElemItem!) { updateCodedEntityArrayItem(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item }
+    }, { contextValue: global.getContext([roles.write]) });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data).toBeDefined();
+    expect(response.body.singleResult.data.updateCodedEntityArrayItem).toBeDefined();
+    expect(response.body.singleResult.data.updateCodedEntityArrayItem.data.items.length).toEqual(ce1.data.items.length);
+    expect(response.body.singleResult.data.updateCodedEntityArrayItem.data.items[1].id).toEqual(item.data.id);
+    expect(response.body.singleResult.data.updateCodedEntityArrayItem.data.items[1].value).toEqual(item.data.value);
+}));
+it('queries GraphQL to remove one array element inside one item', () => __awaiter(void 0, void 0, void 0, function* () {
+    const { ceItem: ce1 } = yield createItem();
+    const item = { path: 'data.items', data: { id: ce1.data.items[1].id } };
+    const response = yield server.executeOperation({
+        query: 'mutation removeCodedEntityArrayItem($id: ID!, $item: RemoveArrayElemItem!) { removeCodedEntityArrayItem(id: $id, item: $item) { id code name data } }',
+        variables: { id: ce1.id, item }
+    }, { contextValue: global.getContext([roles.write]) });
+    (0, assert_1.default)(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data).toBeDefined();
+    expect(response.body.singleResult.data.removeCodedEntityArrayItem).toBeDefined();
+    expect(response.body.singleResult.data.removeCodedEntityArrayItem.data.items.length).toEqual(ce1.data.items.length - 1);
+    expect(response.body.singleResult.data.removeCodedEntityArrayItem.data.items[1].id).not.toEqual(item.data.id);
+    expect(response.body.singleResult.data.removeCodedEntityArrayItem.data.items[1].id).toEqual(ce1.data.items[2].id);
+    response.body.singleResult.data.removeCodedEntityArrayItem.data.items.forEach(di => {
+        expect(di.id).not.toEqual(ce1 === null || ce1 === void 0 ? void 0 : ce1.data.items[1].id);
+    });
+}));

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

@@ -0,0 +1,18 @@
+import { GraphQLSchema } from 'graphql';
+import { BaseUser, NxContext } from '../interfaces';
+export declare function createAuthDirective(directiveName: string, getUserFn: (ctx: NxContext) => BaseUser | null): {
+    name: string;
+    typeDefs: string;
+    transformer: (schema: GraphQLSchema) => GraphQLSchema;
+};
+/**
+ *
+ * @param {*} context
+ * @returns
+ */
+export declare function getUser(context: NxContext): BaseUser | null;
+export declare const authDirective: {
+    name: string;
+    typeDefs: string;
+    transformer: (schema: GraphQLSchema) => GraphQLSchema;
+};