mandarina-server 2.1.11 → 2.1.13

package/build/Table/Table.d.ts

@@ -2,7 +2,7 @@ import { Prisma } from "prisma-binding";
 import { ContextParameters } from "graphql-yoga/dist/types";
 import { ActionType } from "mandarina/build/Auth/Auth";
 import { Schema } from "mandarina";
-import { ErrorFromServerMapper } from "mandarina/src/Schema/Schema";
+import { ErrorFromServerMapper } from "mandarina/build/Schema/Schema";
 import { UserType } from "../Mandarina";
 import { GraphQLResolveInfo } from "graphql";
 /**
@@ -28,7 +28,7 @@ export declare class Table {
     getDefaultActions(type: operationType): {
         [resolverName: string]: (_: any, args: any, context: Context, info: any) => void;
     };
-    insertWhereIntoInfo: (info: GraphQLResolveInfo, user: UserType | null | undefined, isSingleMutation: boolean | undefined, action: "read" | "create" | "update" | "delete", operationName: string) => {
+    insertWhereIntoInfo: (info: GraphQLResolveInfo, user: UserType | null | undefined, isSingleMutation: boolean | undefined, action: ActionType, operationName: string) => {
         fields: string[];
         queryString: string;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mandarina-server",
-  "version": "2.1.11",
+  "version": "2.1.13",
   "description": "Mandarina for server side",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -16,15 +16,15 @@
     "@types/ws": "^6.0.1",
     "@types/graphql-fields": "^1.3.0",
     "graphql-fields": "2.0.3",
-    "yaml": "^1.6.0",
-    "typescript": "3.8.3"
+    "yaml": "^1.6.0"
   },
   "peerDependencies": {
+    "typescript": "3.8.3",
     "lodash": ">=4.17.21",
     "@types/lodash": ">=4.14.192",
     "@types/node": ">=12.0.10",
     "graphql-yoga": ">=1.17.4",
-    "mandarina": "2.1.10",
+    "mandarina": "2.1.12",
     "prisma-binding": ">=2.3.15"
   },
   "devDependencies": {
@@ -32,7 +32,7 @@
     "graphql-yoga": "^1.18.0",
     "jest": "^24.8.0",
     "ts-jest": "22.4.6",
-    "mandarina": "2.1.10",
+    "mandarina": "2.1.12",
     "prisma-binding": "^2.3.15"
   },
   "jest": {

package/src/Action/CustomAction.js

@@ -8,22 +8,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Schema_1 = require("mandarina/build/Schema/Schema");
-const TableInstanceNotFound_1 = require("../Errors/TableInstanceNotFound");
-const UniqueActionError_1 = require("../Errors/UniqueActionError");
-const Mandarina_1 = __importDefault(require("../Mandarina"));
-class CustomAction {
+var Schema_1 = require("mandarina/build/Schema/Schema");
+var TableInstanceNotFound_1 = require("../Errors/TableInstanceNotFound");
+var UniqueActionError_1 = require("../Errors/UniqueActionError");
+var Mandarina_1 = require("../Mandarina");
+var CustomAction = /** @class */ (function () {
     /**
      *
      *
      * @param schema
      * @param actionOptions
      */
-    constructor(schema, actionOptions) {
+    function CustomAction(schema, actionOptions) {
         CustomAction.instances = CustomAction.instances || {};
         if (schema instanceof Schema_1.Schema) {
             this.schema = schema;
@@ -38,48 +62,60 @@ class CustomAction {
         this.actions = actionOptions.actions;
         CustomAction.instances[this.name] = this;
     }
-    static getInstance(name) {
+    CustomAction.getInstance = function (name) {
         if (!CustomAction.instances[name]) {
             throw new TableInstanceNotFound_1.TableInstanceNotFound(name);
         }
         return CustomAction.instances[name];
-    }
-    getFields() {
+    };
+    CustomAction.prototype.getFields = function () {
         return this.schema && this.schema.getFields();
-    }
-    getActions() {
-        const actions = this.actions || {};
-        let result = {};
-        Object.keys(actions).forEach((action) => {
-            result[action] = (_, args, context, info) => __awaiter(this, void 0, void 0, function* () {
-                const user = yield Mandarina_1.default.config.getUser(context);
-                const roles = (user && user.roles) || [];
-                const permissions = actions[action].permission || [];
-                if (permissions.includes('nobody')) {
-                    throw new Error('Action not allowed');
-                }
-                if (permissions.includes('everybody') || permissions.some(permission => roles.includes(permission))) {
-                    console.log('***************', `Action "${action}" not allowed for this user`, '***************');
-                    console.warn(user && user.id, action);
-                    console.warn(user && user.roles, permissions);
-                    console.log('*****************************************************************************');
-                    //throw new Error(`Action "${action}" not allowed for this user`)
-                }
-                const result = yield actions[action].action(_, args, context, info);
-                context.result = result;
-                if (CustomAction.hook) {
-                    context.schemaName = this.name;
-                    context.name = action;
-                    yield CustomAction.hook(_, args, context, info);
-                }
-                return result;
-            });
+    };
+    CustomAction.prototype.getActions = function () {
+        var _this = this;
+        var actions = this.actions || {};
+        var result = {};
+        Object.keys(actions).forEach(function (action) {
+            result[action] = function (_, args, context, info) { return __awaiter(_this, void 0, void 0, function () {
+                var user, roles, permissions, result;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, Mandarina_1.default.config.getUser(context)];
+                        case 1:
+                            user = _a.sent();
+                            roles = (user && user.roles) || [];
+                            permissions = actions[action].permission || [];
+                            if (permissions.includes('nobody')) {
+                                throw new Error('Action not allowed');
+                            }
+                            if (permissions.includes('everybody') || permissions.some(function (permission) { return roles.includes(permission); })) {
+                                console.log('***************', "Action \"" + action + "\" not allowed for this user", '***************');
+                                console.warn(user && user.id, action);
+                                console.warn(user && user.roles, permissions);
+                                console.log('*****************************************************************************');
+                                //throw new Error(`Action "${action}" not allowed for this user`)
+                            }
+                            return [4 /*yield*/, actions[action].action(_, args, context, info)];
+                        case 2:
+                            result = _a.sent();
+                            context.result = result;
+                            if (!CustomAction.hook) return [3 /*break*/, 4];
+                            context.schemaName = this.name;
+                            context.name = action;
+                            return [4 /*yield*/, CustomAction.hook(_, args, context, info)];
+                        case 3:
+                            _a.sent();
+                            _a.label = 4;
+                        case 4: return [2 /*return*/, result];
+                    }
+                });
+            }); };
         });
         return result;
-    }
-}
+    };
+    CustomAction.setGlobalHook = function (hook) {
+        CustomAction.hook = hook;
+    };
+    return CustomAction;
+}());
 exports.CustomAction = CustomAction;
-CustomAction.setGlobalHook = (hook) => {
-    CustomAction.hook = hook;
-};
-//# sourceMappingURL=CustomAction.js.map

package/src/Errors/TableInstanceNotFound.js

@@ -1,13 +1,24 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const BaseError_1 = __importDefault(require("mandarina/build/Errors/BaseError"));
-class TableInstanceNotFound extends BaseError_1.default {
-    constructor(schemaName) {
-        super(`The table ${schemaName} was not instantiated`);
+var BaseError_1 = require("mandarina/build/Errors/BaseError");
+var TableInstanceNotFound = /** @class */ (function (_super) {
+    __extends(TableInstanceNotFound, _super);
+    function TableInstanceNotFound(schemaName) {
+        return _super.call(this, "The table " + schemaName + " was not instantiated") || this;
     }
-}
+    return TableInstanceNotFound;
+}(BaseError_1.default));
 exports.TableInstanceNotFound = TableInstanceNotFound;
-//# sourceMappingURL=TableInstanceNotFound.js.map

package/src/Errors/UniqueActionError.js

@@ -1,14 +1,27 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const BaseError_1 = __importDefault(require("mandarina/build/Errors/BaseError"));
-class UniqueActionError extends BaseError_1.default {
-    constructor(schemaName) {
-        const name = typeof schemaName === "string" ? schemaName : schemaName.name;
-        super(`The action "${name}" already exists, action name should be unique.`);
+var BaseError_1 = require("mandarina/build/Errors/BaseError");
+var UniqueActionError = /** @class */ (function (_super) {
+    __extends(UniqueActionError, _super);
+    function UniqueActionError(schemaName) {
+        var _this = this;
+        var name = typeof schemaName === "string" ? schemaName : schemaName.name;
+        _this = _super.call(this, "The action \"" + name + "\" already exists, action name should be unique.") || this;
+        return _this;
     }
-}
+    return UniqueActionError;
+}(BaseError_1.default));
 exports.UniqueActionError = UniqueActionError;
-//# sourceMappingURL=UniqueActionError.js.map

package/src/Mandarina.js

@@ -1,41 +1,57 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const Table_1 = require("./Table/Table");
-const CustomAction_1 = require("./Action/CustomAction");
-const utils_1 = require("./cli/utils");
-class Mandarina {
-    static load() {
-        const config = utils_1.getConfig();
-        utils_1.loadSchemas(config.dir);
+var Table_1 = require("./Table/Table");
+var CustomAction_1 = require("./Action/CustomAction");
+var utils_1 = require("./cli/utils");
+var Mandarina = /** @class */ (function () {
+    function Mandarina() {
     }
-    static getQuery() {
-        let Query = {};
-        for (const tableName in Table_1.Table.instances) {
-            const table = Table_1.Table.getInstance(tableName);
-            Query = Object.assign(Object.assign({}, Query), table.getDefaultActions('query'));
+    Mandarina.load = function () {
+        var config = utils_1.getConfig();
+        utils_1.loadSchemas(config.dir);
+    };
+    Mandarina.getQuery = function () {
+        var Query = {};
+        for (var tableName in Table_1.Table.instances) {
+            var table = Table_1.Table.getInstance(tableName);
+            Query = __assign(__assign({}, Query), table.getDefaultActions('query'));
         }
         return Query;
-    }
-    static getMutation() {
-        let Mutation = {};
-        for (const tableName in Table_1.Table.instances) {
-            const table = Table_1.Table.getInstance(tableName);
-            Mutation = Object.assign(Object.assign({}, Mutation), table.getDefaultActions('mutation'));
+    };
+    Mandarina.getMutation = function () {
+        var Mutation = {};
+        for (var tableName in Table_1.Table.instances) {
+            var table = Table_1.Table.getInstance(tableName);
+            Mutation = __assign(__assign({}, Mutation), table.getDefaultActions('mutation'));
         }
-        for (const actionName in CustomAction_1.CustomAction.instances) {
-            const action = CustomAction_1.CustomAction.getInstance(actionName);
-            Mutation = Object.assign(Object.assign({}, Mutation), action.getActions());
+        for (var actionName in CustomAction_1.CustomAction.instances) {
+            var action = CustomAction_1.CustomAction.getInstance(actionName);
+            Mutation = __assign(__assign({}, Mutation), action.getActions());
         }
         return Mutation;
-    }
-}
+    };
+    Mandarina.config = {
+        getUser: function (_a) {
+            var user = _a.user;
+            return user;
+        },
+    };
+    Mandarina.configure = function (options) {
+        if (options.getUser) {
+            Mandarina.config.getUser = options.getUser;
+        }
+    };
+    return Mandarina;
+}());
 exports.default = Mandarina;
-Mandarina.config = {
-    getUser: ({ user }) => user,
-};
-Mandarina.configure = (options) => {
-    if (options.getUser) {
-        Mandarina.config.getUser = options.getUser;
-    }
-};
-//# sourceMappingURL=Mandarina.js.map

package/src/Table/Table.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 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) {
@@ -8,20 +19,44 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const mandarina_1 = require("mandarina");
-const UniqueSchemaError_1 = require("mandarina/build/Errors/UniqueSchemaError");
-const SchemaInstanceNotFound_1 = require("mandarina/build/Errors/SchemaInstanceNotFound");
-const utils_1 = require("mandarina/build/Schema/utils");
-const MissingIDTableError_1 = require("mandarina/build/Errors/MissingIDTableError");
-const Mandarina_1 = __importDefault(require("../Mandarina"));
-const Mutate_1 = require("mandarina/build/Operations/Mutate");
-const language_1 = require("graphql/language");
-const stringify_object_1 = __importDefault(require("stringify-object"));
-const lodash_1 = require("lodash");
+var mandarina_1 = require("mandarina");
+var UniqueSchemaError_1 = require("mandarina/build/Errors/UniqueSchemaError");
+var SchemaInstanceNotFound_1 = require("mandarina/build/Errors/SchemaInstanceNotFound");
+var utils_1 = require("mandarina/build/Schema/utils");
+var MissingIDTableError_1 = require("mandarina/build/Errors/MissingIDTableError");
+var Mandarina_1 = require("../Mandarina");
+var Mutate_1 = require("mandarina/build/Operations/Mutate");
+var language_1 = require("graphql/language");
+var stringify_object_1 = require("stringify-object");
+var lodash_1 = require("lodash");
 // import {flatten, unflatten} from "flat";
 /**
  *
@@ -30,16 +65,21 @@ const lodash_1 = require("lodash");
  * Form
  * List of results
  */
-class Table {
-    constructor(schema, tableOptions) {
-        this.insertWhereIntoInfo = (info, user, isSingleMutation = false, action, operationName) => {
+var Table = /** @class */ (function () {
+    function Table(schema, tableOptions) {
+        var _this = this;
+        this.insertWhereIntoInfo = function (info, user, isSingleMutation, action, operationName) {
+            if (isSingleMutation === void 0) { isSingleMutation = false; }
             var _a, _b;
-            const field = [];
-            const fields = new Set();
-            let required = false;
-            const allowedVariables = ((_b = (_a = info.fieldNodes[0]) === null || _a === void 0 ? void 0 : _a.arguments) === null || _b === void 0 ? void 0 : _b.map(({ name: { value } }) => value)) || [];
-            const query = language_1.visit(info.operation, {
-                enter: (node, key, parent, path, ancestors) => {
+            var field = [];
+            var fields = new Set();
+            var required = false;
+            var allowedVariables = ((_b = (_a = info.fieldNodes[0]) === null || _a === void 0 ? void 0 : _a.arguments) === null || _b === void 0 ? void 0 : _b.map(function (_a) {
+                var value = _a.name.value;
+                return value;
+            })) || [];
+            var query = language_1.visit(info.operation, {
+                enter: function (node, key, parent, path, ancestors) {
                     if (node.kind === 'VariableDefinition') {
                         if (!allowedVariables.includes(node === null || node === void 0 ? void 0 : node.variable.name.value)) {
                             return null;
@@ -50,31 +90,31 @@ class Table {
                     }
                     if (node.kind === 'Field' && node.name.value !== '__typename') {
                         field.push(node.name.value);
-                        const internalField = field.slice(1).join('.');
-                        let table;
+                        var internalField = field.slice(1).join('.');
+                        var table = void 0;
                         if (internalField) {
                             fields.add(internalField);
-                            const def = this.schema.getPathDefinition(internalField);
+                            var def = _this.schema.getPathDefinition(internalField);
                             if (def.isTable && def.isArray) {
                                 table = Table.instances[def.type];
                             }
                         }
                         else {
-                            table = this;
+                            table = _this;
                         }
-                        if (table && table.options.where && (!isSingleMutation && table === this)) {
-                            const where = table.options.where(user, action, operationName);
+                        if (table && table.options.where && (!isSingleMutation && table === _this)) {
+                            var where = table.options.where(user, action, operationName);
                             if (!where || lodash_1.isEmpty(where))
                                 return;
-                            const clone = Mutate_1.deepClone(node);
-                            const originalWhereObj = clone.arguments ? clone.arguments.find((a) => a.name.value === 'where') : null;
-                            let originalWhereString = '';
-                            if (originalWhereObj && table === this) {
+                            var clone = Mutate_1.deepClone(node);
+                            var originalWhereObj = clone.arguments ? clone.arguments.find(function (a) { return a.name.value === 'where'; }) : null;
+                            var originalWhereString = '';
+                            if (originalWhereObj && table === _this) {
                                 originalWhereString = language_1.print(originalWhereObj.value);
                                 required = true;
                             }
-                            const newWhereString = stringify_object_1.default(where, { singleQuotes: false });
-                            let finalWhereString = originalWhereString ? `{AND:[${originalWhereString},${newWhereString}]}` : newWhereString;
+                            var newWhereString = stringify_object_1.default(where, { singleQuotes: false });
+                            var finalWhereString = originalWhereString ? "{AND:[" + originalWhereString + "," + newWhereString + "]}" : newWhereString;
                             if (originalWhereObj) {
                                 originalWhereObj.value = language_1.parseValue(new language_1.Source(finalWhereString));
                             }
@@ -90,17 +130,17 @@ class Table {
                     }
                     return;
                 },
-                leave(node) {
+                leave: function (node) {
                     if (node.kind === 'Field' && node.name.value !== '__typename') {
                         field.pop();
                     }
                 }
             });
-            let queryString = language_1.print(query);
+            var queryString = language_1.print(query);
             if (required) {
                 queryString = queryString.replace(/\$where: (\w*)Input(,| |\))/, '$where: $1Input!$2');
             }
-            return { fields: Array.from(fields), queryString };
+            return { fields: Array.from(fields), queryString: queryString };
         };
         Table.instances = Table.instances || {};
         this.schema = schema;
@@ -111,18 +151,18 @@ class Table {
         if (Table.instances[this.name]) {
             throw new UniqueSchemaError_1.UniqueSchemaError(this.name);
         }
-        this.options = Object.assign({}, tableOptions);
+        this.options = __assign({}, tableOptions);
         Table.instances[this.name] = this;
     }
-    static getInstance(name) {
+    Table.getInstance = function (name) {
         if (!Table.instances[name]) {
             throw new SchemaInstanceNotFound_1.SchemaInstanceNotFound(name);
         }
         return Table.instances[name];
-    }
-    getFields() {
+    };
+    Table.prototype.getFields = function () {
         return this.schema.getFields();
-    }
+    };
     /*
      * It apply the fields permissions policy by action and roles, throw an exception if is not a valid request
      *
@@ -142,112 +182,114 @@ class Table {
         }
     }
  */
-    shouldHasManyUpdate() {
-        const fields = this.schema.getFields().filter(f => f !== 'createdAt' && f !== 'createdAt');
+    Table.prototype.shouldHasManyUpdate = function () {
+        var fields = this.schema.getFields().filter(function (f) { return f !== 'createdAt' && f !== 'createdAt'; });
         return fields.length > 0;
-    }
+    };
     //Insert where option in to the query
     // static dotConcat = (a: string | undefined, b: string) => a ? `${a}.${b}` : b;
-    getDefaultActions(type) {
+    Table.prototype.getDefaultActions = function (type) {
+        var _this = this;
         // OperationName for query is user or users, for mutation are createUser, updateUser ....
-        const operationNames = Object.values(this.schema.names[type]);
-        const resultResolvers = {};
-        operationNames.forEach((operationName) => {
-            if (!this.shouldHasManyUpdate())
+        var operationNames = Object.values(this.schema.names[type]);
+        var resultResolvers = {};
+        operationNames.forEach(function (operationName) {
+            if (!_this.shouldHasManyUpdate())
                 return;
-            resultResolvers[operationName] = (_, args = {}, context, info) => __awaiter(this, void 0, void 0, function* () {
-                context.originalArgs = args;
-                const user = yield Mandarina_1.default.config.getUser(context);
-                const subOperationName = operationName.substr(0, 6);
-                const action = (['create', 'update', 'delete'].includes(subOperationName) ? subOperationName : 'read');
-                context.action = action;
-                let result;
-                const capitalizedAction = utils_1.capitalize(action);
-                context.operationName = operationName;
-                yield this.callHook(this.name, 'beforeValidate', _, args, context, info);
-                const isSingleMutation = operationName === this.schema.names.mutation.update || operationName === this.schema.names.mutation.create;
-                let { queryString, fields } = this.insertWhereIntoInfo(info, user, isSingleMutation, action, operationName);
-                if (type === 'mutation') {
-                    // if (errors.length > 0) {
-                    //     await this.callHook('validationFailed', action, _, args, context, info);
-                    // } else {
-                    //     await this.callHook('afterValidate', action, _, args, context, info);
-                    // }
-                    if (isSingleMutation && (action === 'update' || action === 'delete')) {
-                        const where = this.options.where && this.options.where(user, action, operationName);
-                        if (where) {
-                            let finalWhere = args.where ? { AND: [args.where, where] } : where;
-                            const exists = (yield context.prisma.exists[this.name](finalWhere));
-                            if (!exists) {
-                                throw new Error(`${action} on ${this.schema.name} not found for ${JSON.stringify(where)}`);
-                            }
+            resultResolvers[operationName] = function (_, args, context, info) {
+                if (args === void 0) { args = {}; }
+                return __awaiter(_this, void 0, void 0, function () {
+                    var user, subOperationName, action, result, capitalizedAction, isSingleMutation, _a, queryString, fields, where, finalWhere, exists, data, data;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                context.originalArgs = args;
+                                return [4 /*yield*/, Mandarina_1.default.config.getUser(context)];
+                            case 1:
+                                user = _b.sent();
+                                subOperationName = operationName.substr(0, 6);
+                                action = (['create', 'update', 'delete'].includes(subOperationName) ? subOperationName : 'read');
+                                context.action = action;
+                                capitalizedAction = utils_1.capitalize(action);
+                                context.operationName = operationName;
+                                return [4 /*yield*/, this.callHook(this.name, 'beforeValidate', _, args, context, info)];
+                            case 2:
+                                _b.sent();
+                                isSingleMutation = operationName === this.schema.names.mutation.update || operationName === this.schema.names.mutation.create;
+                                _a = this.insertWhereIntoInfo(info, user, isSingleMutation, action, operationName), queryString = _a.queryString, fields = _a.fields;
+                                if (!(type === 'mutation')) return [3 /*break*/, 8];
+                                if (!(isSingleMutation && (action === 'update' || action === 'delete'))) return [3 /*break*/, 4];
+                                where = this.options.where && this.options.where(user, action, operationName);
+                                if (!where) return [3 /*break*/, 4];
+                                finalWhere = args.where ? { AND: [args.where, where] } : where;
+                                return [4 /*yield*/, context.prisma.exists[this.name](finalWhere)];
+                            case 3:
+                                exists = (_b.sent());
+                                if (!exists) {
+                                    throw new Error(action + " on " + this.schema.name + " not found for " + JSON.stringify(where));
+                                }
+                                _b.label = 4;
+                            case 4:
+                                //VALIDATE IF USER CAN MUTATE THOSE FIELDS
+                                this.schema.validateMutation(action, Mutate_1.deepClone(args), user && user.roles || []);
+                                return [4 /*yield*/, this.callHook(this.name, "before" + capitalizedAction, _, args, context, info)];
+                            case 5:
+                                _b.sent();
+                                return [4 /*yield*/, context.prisma.request(queryString, args)];
+                            case 6:
+                                data = (_b.sent());
+                                if (data.errors) {
+                                    console.error(data.errors);
+                                }
+                                result = Object.values(data.data)[0];
+                                context.result = result;
+                                return [4 /*yield*/, this.callHook(this.name, "after" + capitalizedAction, _, args, context, info)];
+                            case 7:
+                                _b.sent();
+                                this.schema.validateQuery(fields, user && user.roles || []);
+                                _b.label = 8;
+                            case 8:
+                                if (!(type === 'query')) return [3 /*break*/, 12];
+                                // console.dir(JSON.parse(JSON.stringify(info)),{depth:1})
+                                return [4 /*yield*/, this.callHook(this.name, 'beforeQuery', _, args, context, info)];
+                            case 9:
+                                // console.dir(JSON.parse(JSON.stringify(info)),{depth:1})
+                                _b.sent();
+                                if (!!info.fieldName.match(/Connection$/)) {
+                                    this.schema.validateConnection(user && user.roles || []);
+                                }
+                                else {
+                                    this.schema.validateQuery(fields, user && user.roles || []);
+                                }
+                                //Validate if the roles is able to read those fields
+                                if (operationName === this.schema.names.query.single) {
+                                    queryString = queryString.replace(operationName, this.schema.names.query.plural);
+                                    queryString = queryString.replace(new RegExp(this.schema.names.input.where.single + "!?"), this.schema.names.input.where.plural + '!');
+                                }
+                                return [4 /*yield*/, context.prisma.request(queryString, args)];
+                            case 10:
+                                data = (_b.sent());
+                                if (data.errors) {
+                                    console.error(data.errors);
+                                }
+                                result = Object.values(data.data)[0];
+                                if (operationName === this.schema.names.query.single) {
+                                    result = data.data[this.schema.names.query.plural];
+                                    result = result && result.length === 1 ? result[0] : null;
+                                }
+                                context.result = result;
+                                return [4 /*yield*/, this.callHook(this.name, 'afterQuery', _, args, context, info)];
+                            case 11:
+                                _b.sent();
+                                _b.label = 12;
+                            case 12: return [2 /*return*/, result];
                         }
-                    }
-                    //VALIDATE IF USER CAN MUTATE THOSE FIELDS
-                    this.schema.validateMutation(action, Mutate_1.deepClone(args), user && user.roles || []);
-                    yield this.callHook(this.name, `before${capitalizedAction}`, _, args, context, info);
-                    /*
-                    HACK https://github.com/prisma/prisma/issues/4327
-                     */
-                    // if (`before${capitalizedAction}` === 'beforeUpdate' || `before${capitalizedAction}` === 'beforeCreate') {
-                    //     const flat = flatten(args.data)
-                    //     const where = args.where
-                    //     let run = false
-                    //     let withDeleteMany: any = {}
-                    //     let withoutDeleteMany: any = {}
-                    //     Object.keys(flat).forEach((key) => {
-                    //         if (key.match(/\.deleteMany\.0$/)) {
-                    //             run = true
-                    //             withDeleteMany[key] = flat[key]
-                    //         } else {
-                    //             withoutDeleteMany[key] = flat[key]
-                    //         }
-                    //     })
-                    //     if (run) {
-                    //         await prismamethod({where, data: unflatten(withdeletemany)}, info);
-                    //         args.data = unflatten(withoutDeleteMany)
-                    //     }
-                    // }
-                    const data = (yield context.prisma.request(queryString, args));
-                    if (data.errors) {
-                        console.error(data.errors);
-                    }
-                    result = Object.values(data.data)[0];
-                    context.result = result;
-                    yield this.callHook(this.name, `after${capitalizedAction}`, _, args, context, info);
-                    this.schema.validateQuery(fields, user && user.roles || []);
-                }
-                if (type === 'query') {
-                    // console.dir(JSON.parse(JSON.stringify(info)),{depth:1})
-                    yield this.callHook(this.name, 'beforeQuery', _, args, context, info);
-                    if (!!info.fieldName.match(/Connection$/)) {
-                        this.schema.validateConnection(user && user.roles || []);
-                    }
-                    else {
-                        this.schema.validateQuery(fields, user && user.roles || []);
-                    }
-                    //Validate if the roles is able to read those fields
-                    if (operationName === this.schema.names.query.single) {
-                        queryString = queryString.replace(operationName, this.schema.names.query.plural);
-                        queryString = queryString.replace(new RegExp(`${this.schema.names.input.where.single}!?`), this.schema.names.input.where.plural + '!');
-                    }
-                    const data = (yield context.prisma.request(queryString, args));
-                    if (data.errors) {
-                        console.error(data.errors);
-                    }
-                    result = Object.values(data.data)[0];
-                    if (operationName === this.schema.names.query.single) {
-                        result = data.data[this.schema.names.query.plural];
-                        result = result && result.length === 1 ? result[0] : null;
-                    }
-                    context.result = result;
-                    yield this.callHook(this.name, 'afterQuery', _, args, context, info);
-                }
-                return result;
-            });
+                    });
+                });
+            };
         });
         return resultResolvers;
-    }
+    };
     /**
      * Go back a mutation object to the original object
      */
@@ -261,80 +303,114 @@ class Table {
      * @param context
      * @param info
      */
-    callHook(schemaName, name, _, args, context, info) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let prefix = '';
-                if (name.indexOf('before') === 0)
-                    prefix = 'before';
-                if (name.indexOf('after') === 0)
-                    prefix = 'after';
-                const globalHookHandler = Table.hooks[name];
-                const hookHandler = this.options.hooks && this.options.hooks[name];
-                if (args.data && prefix) {
-                    const fields = Object.keys(args.data);
-                    const schema = mandarina_1.Schema.getInstance(schemaName);
-                    for (const field of fields) {
-                        const def = schema.getPathDefinition(field);
-                        const inline = !!(def.table && def.table.relation && def.table.relation.link === 'INLINE');
-                        if (def.isTable) {
-                            const operations = Object.keys(args.data[field]);
-                            if (!Table.instances[def.type]) {
-                                //console.warn(`No table for ${def.type} no neasted hooks applied`)
-                                continue;
-                            }
-                            const table = Table.getInstance(def.type);
-                            for (const operation of operations) {
-                                const hookName = `${prefix}${utils_1.capitalize(operation)}`;
-                                const args2 = args.data[field][operation];
-                                if (Array.isArray(args2)) {
-                                    for (const arg2 of args2) {
-                                        if (inline) {
-                                            yield table.callHook(def.type, hookName, _, arg2.data ? arg2 : { data: arg2 }, context, info);
-                                        }
-                                        else {
-                                            yield table.callHook(def.type, hookName, _, arg2.data ? arg2 : { data: arg2 }, context, info);
-                                        }
-                                    }
-                                }
-                                else {
-                                    if (inline) {
-                                        yield table.callHook(def.type, hookName, _, args2.data ? args2 : { data: args2 }, context, info);
-                                    }
-                                    else {
-                                        yield table.callHook(def.type, hookName, _, args2.data ? args2 : { data: args2 }, context, info);
-                                    }
-                                }
-                            }
+    Table.prototype.callHook = function (schemaName, name, _, args, context, info) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prefix, globalHookHandler, hookHandler, fields, schema, _i, fields_1, field, def, inline, operations, table, _a, operations_1, operation, hookName, args2, _b, args2_1, arg2, e_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 20, , 21]);
+                        prefix = '';
+                        if (name.indexOf('before') === 0)
+                            prefix = 'before';
+                        if (name.indexOf('after') === 0)
+                            prefix = 'after';
+                        globalHookHandler = Table.hooks[name];
+                        hookHandler = this.options.hooks && this.options.hooks[name];
+                        if (!(args.data && prefix)) return [3 /*break*/, 15];
+                        fields = Object.keys(args.data);
+                        schema = mandarina_1.Schema.getInstance(schemaName);
+                        _i = 0, fields_1 = fields;
+                        _c.label = 1;
+                    case 1:
+                        if (!(_i < fields_1.length)) return [3 /*break*/, 15];
+                        field = fields_1[_i];
+                        def = schema.getPathDefinition(field);
+                        inline = !!(def.table && def.table.relation && def.table.relation.link === 'INLINE');
+                        if (!def.isTable) return [3 /*break*/, 14];
+                        operations = Object.keys(args.data[field]);
+                        if (!Table.instances[def.type]) {
+                            //console.warn(`No table for ${def.type} no neasted hooks applied`)
+                            return [3 /*break*/, 14];
                         }
-                    }
-                }
-                if (globalHookHandler) {
-                    context.schemaName = schemaName;
-                    context.name = name;
-                    yield globalHookHandler(_, args, context, info);
-                }
-                if (hookHandler) {
-                    yield hookHandler(_, args, context, info);
+                        table = Table.getInstance(def.type);
+                        _a = 0, operations_1 = operations;
+                        _c.label = 2;
+                    case 2:
+                        if (!(_a < operations_1.length)) return [3 /*break*/, 14];
+                        operation = operations_1[_a];
+                        hookName = "" + prefix + utils_1.capitalize(operation);
+                        args2 = args.data[field][operation];
+                        if (!Array.isArray(args2)) return [3 /*break*/, 9];
+                        _b = 0, args2_1 = args2;
+                        _c.label = 3;
+                    case 3:
+                        if (!(_b < args2_1.length)) return [3 /*break*/, 8];
+                        arg2 = args2_1[_b];
+                        if (!inline) return [3 /*break*/, 5];
+                        return [4 /*yield*/, table.callHook(def.type, hookName, _, arg2.data ? arg2 : { data: arg2 }, context, info)];
+                    case 4:
+                        _c.sent();
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, table.callHook(def.type, hookName, _, arg2.data ? arg2 : { data: arg2 }, context, info)];
+                    case 6:
+                        _c.sent();
+                        _c.label = 7;
+                    case 7:
+                        _b++;
+                        return [3 /*break*/, 3];
+                    case 8: return [3 /*break*/, 13];
+                    case 9:
+                        if (!inline) return [3 /*break*/, 11];
+                        return [4 /*yield*/, table.callHook(def.type, hookName, _, args2.data ? args2 : { data: args2 }, context, info)];
+                    case 10:
+                        _c.sent();
+                        return [3 /*break*/, 13];
+                    case 11: return [4 /*yield*/, table.callHook(def.type, hookName, _, args2.data ? args2 : { data: args2 }, context, info)];
+                    case 12:
+                        _c.sent();
+                        _c.label = 13;
+                    case 13:
+                        _a++;
+                        return [3 /*break*/, 2];
+                    case 14:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 15:
+                        if (!globalHookHandler) return [3 /*break*/, 17];
+                        context.schemaName = schemaName;
+                        context.name = name;
+                        return [4 /*yield*/, globalHookHandler(_, args, context, info)];
+                    case 16:
+                        _c.sent();
+                        _c.label = 17;
+                    case 17:
+                        if (!hookHandler) return [3 /*break*/, 19];
+                        return [4 /*yield*/, hookHandler(_, args, context, info)];
+                    case 18:
+                        _c.sent();
+                        _c.label = 19;
+                    case 19: return [3 /*break*/, 21];
+                    case 20:
+                        e_1 = _c.sent();
+                        console.error("Error executing hook: \"" + name + "\" in Table: " + schemaName + "\"");
+                        console.error(e_1);
+                        throw e_1;
+                    case 21: return [2 /*return*/];
                 }
-            }
-            catch (e) {
-                console.error(`Error executing hook: "${name}" in Table: ${schemaName}"`);
-                console.error(e);
-                throw e;
-            }
+            });
         });
-    }
-}
+    };
+    Table.hooks = {};
+    Table.setGlobalHooks = function (hooks) {
+        Table.hooks = hooks;
+    };
+    return Table;
+}());
 exports.Table = Table;
-Table.hooks = {};
-Table.setGlobalHooks = (hooks) => {
-    Table.hooks = hooks;
-};
 // let time = new Date().getTime()
 // export function bm(description = '',...args:any) {
 //     description && console.info(description,...args, new Date().getTime() - time)
 //     time = new Date().getTime()
 //
 // }
-//# sourceMappingURL=Table.js.map

package/src/Table/Table.ts

@@ -7,7 +7,7 @@ import {UniqueSchemaError} from 'mandarina/build/Errors/UniqueSchemaError';
 import {SchemaInstanceNotFound} from "mandarina/build/Errors/SchemaInstanceNotFound";
 import {capitalize} from 'mandarina/build/Schema/utils';
 import {MissingIdTableError} from "mandarina/build/Errors/MissingIDTableError";
-import {ErrorFromServerMapper} from "mandarina/src/Schema/Schema";
+import {ErrorFromServerMapper} from "mandarina/build/Schema/Schema";
 import Mandarina, {UserType} from "../Mandarina";
 import {deepClone} from "mandarina/build/Operations/Mutate";
 import {parseValue, print, Source, visit} from 'graphql/language'

package/src/cli/utils.js

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadSchemas = exports.getConfig = void 0;
-var fs_1 = __importDefault(require("fs"));
-var path_1 = __importDefault(require("path"));
-var getConfig = function () {
+var fs_1 = require("fs");
+var path_1 = require("path");
+exports.getConfig = function () {
     var rawData;
     try {
         rawData = fs_1.default.readFileSync(path_1.default.join(process.cwd(), 'mandarina.json'), 'utf8');
@@ -35,7 +31,6 @@ var getConfig = function () {
     }
     return (config);
 };
-exports.getConfig = getConfig;
 var walkSync = function (dir, fileList) {
     var files = fs_1.default.readdirSync(dir);
     fileList = fileList || [];
@@ -51,7 +46,7 @@ var walkSync = function (dir, fileList) {
     });
     return fileList;
 };
-var loadSchemas = function (dir) {
+exports.loadSchemas = function (dir) {
     var tables = [];
     var schemas = [];
     var actions = [];
@@ -90,5 +85,3 @@ var loadSchemas = function (dir) {
         }
     });
 };
-exports.loadSchemas = loadSchemas;
-//# sourceMappingURL=utils.js.map