graphile-build-pg 4.13.0 → 4.14.1

package/node8plus/plugins/PgBasicsPlugin.js

@@ -5,81 +5,51 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 exports.preventEmptyResult = preventEmptyResult;
-
 var sql = _interopRequireWildcard(require("pg-sql2"));
-
 var _package = require("../../package.json");
-
 var _pgField = _interopRequireDefault(require("./pgField"));
-
 var _queryFromResolveDataFactory = _interopRequireDefault(require("../queryFromResolveDataFactory"));
-
 var _addStartEndCursor = _interopRequireDefault(require("./addStartEndCursor"));
-
 var _omit = _interopRequireWildcard(require("../omit"));
-
 var _makeProcField = _interopRequireWildcard(require("./makeProcField"));
-
 var _PgComputedColumnsPlugin = require("./PgComputedColumnsPlugin");
-
 var _parseIdentifier = _interopRequireDefault(require("../parseIdentifier"));
-
 var _viaTemporaryTable = _interopRequireDefault(require("./viaTemporaryTable"));
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
 var _pickBy = _interopRequireDefault(require("lodash/pickBy"));
-
 var _PgLiveProvider = _interopRequireDefault(require("../PgLiveProvider"));
-
 var _pgPrepareAndRun = _interopRequireDefault(require("../pgPrepareAndRun"));
-
 var _debugSql = require("./debugSql");
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
 const defaultPgColumnFilter = (_attr, _build, _context) => true;
-
 const identity = _ => _;
-
 function preventEmptyResult(obj) {
   return Object.keys(obj).reduce((memo, key) => {
     const fn = obj[key];
-
     memo[key] = function (...args) {
       const result = fn.apply(this, args);
-
       if (typeof result !== "string" || result.length === 0) {
         const stringifiedArgs = require("util").inspect(args);
-
         throw new Error(`Inflector for '${key}' returned '${String(result)}'; expected non-empty string\n` + `See: https://github.com/graphile/graphile-engine/blob/master/packages/graphile-build-pg/src/plugins/PgBasicsPlugin.js\n` + `Arguments passed to ${key}:\n${stringifiedArgs}`);
       }
-
       return result;
     };
-
     return memo;
   }, {});
 }
-
 const omitWithRBACChecks = omit => (entity, permission) => {
   const ORDINARY_TABLE = "r";
   const VIEW = "v";
   const MATERIALIZED_VIEW = "m";
-
   const isTableLike = entity => entity && entity.kind === "class" && (entity.classKind === ORDINARY_TABLE || entity.classKind === VIEW || entity.classKind === MATERIALIZED_VIEW);
-
   if (entity.kind === "procedure") {
     if (permission === _omit.EXECUTE && !entity.aclExecutable) {
       return true;
     }
   } else if (entity.kind === "class" && isTableLike(entity)) {
     const tableEntity = entity;
-
     if ((permission === _omit.READ || permission === _omit.ALL || permission === _omit.MANY) && !tableEntity.aclSelectable && !tableEntity.attributes.some(attr => attr.aclSelectable)) {
       return true;
     } else if (permission === _omit.CREATE && !tableEntity.aclInsertable && !tableEntity.attributes.some(attr => attr.aclInsertable)) {
@@ -91,8 +61,8 @@ const omitWithRBACChecks = omit => (entity, permission) => {
     }
   } else if (entity.kind === "attribute" && isTableLike(entity.class)) {
     const attributeEntity = entity;
-    const klass = attributeEntity.class; // Have we got *any* permissions on the table?
-
+    const klass = attributeEntity.class;
+    // Have we got *any* permissions on the table?
     if (klass.aclSelectable || klass.attributes.some(attr => attr.aclSelectable)) {
       // Yes; this is a regular table; omit if RBAC permissions tell us to.
       if ((permission === _omit.READ || permission === _omit.FILTER || permission === _omit.ORDER) && !attributeEntity.aclSelectable) {
@@ -102,53 +72,44 @@ const omitWithRBACChecks = omit => (entity, permission) => {
       } else if (permission === _omit.UPDATE && !attributeEntity.aclUpdatable) {
         return true;
       }
-    } else {// No permissions on the table at all, so normal connections will skip
+    } else {
+      // No permissions on the table at all, so normal connections will skip
       // over it. Thus we must be being exposed via a security definer function
       // or similar, so we should expose all fields except those that are
       // explicitly @omit-ed.
     }
   }
-
   return omit(entity, permission);
 };
-
 const omitUnindexed = (omit, hideIndexWarnings) => (entity, permission) => {
   if (entity.kind === "attribute" && !entity.isIndexed && (permission === "filter" || permission === "order")) {
     return true;
   }
-
   if (entity.kind === "constraint" && entity.type === "f" && !entity.isIndexed && permission === "read") {
     const klass = entity.class;
-
     if (klass) {
-      const shouldOutputWarning = // $FlowFixMe
+      const shouldOutputWarning =
+      // $FlowFixMe
       !entity._omitUnindexedReadWarningGiven && !hideIndexWarnings;
-
       if (shouldOutputWarning) {
         // $FlowFixMe
-        entity._omitUnindexedReadWarningGiven = true; // eslint-disable-next-line no-console
-
+        entity._omitUnindexedReadWarningGiven = true;
+        // eslint-disable-next-line no-console
         console.log("%s", `Disabled 'read' permission for ${describePgEntity(entity)} because it isn't indexed. For more information see https://graphile.org/postgraphile/best-practices/ To fix, perform\n\n  CREATE INDEX ON ${`"${klass.namespaceName}"."${klass.name}"`}("${entity.keyAttributes.map(a => a.name).join('", "')}");`);
       }
     }
-
     return true;
   }
-
   return omit(entity, permission);
 };
-
 function describePgEntity(entity, includeAlias = true) {
   const getAlias = !includeAlias ? () => "" : () => {
     const tags = (0, _pickBy.default)(entity.tags, (value, key) => key === "name" || key.endsWith("Name"));
-
     if (Object.keys(tags).length) {
       return ` (with smart comments: ${_chalk.default.bold(Object.keys(tags).map(t => `@${t} ${tags[t]}`).join(" | "))})`;
     }
-
     return "";
   };
-
   try {
     if (entity.kind === "constraint") {
       return `constraint ${_chalk.default.bold(`"${entity.name}"`)} on ${describePgEntity(entity.class, false)}${getAlias()}`;
@@ -170,18 +131,17 @@ function describePgEntity(entity, includeAlias = true) {
     }
   } catch (e) {
     // eslint-disable-next-line no-console
-    console.error("Error occurred while attempting to debug entity:", entity); // eslint-disable-next-line no-console
-
+    console.error("Error occurred while attempting to debug entity:", entity);
+    // eslint-disable-next-line no-console
     console.error(e);
   }
-
   return `entity of kind '${entity.kind}' with ${typeof entity.id === "string" ? `oid '${entity.id}'` : ""}`;
 }
-
 function sqlCommentByAddingTags(entity, tagsToAdd) {
   // NOTE: this function is NOT intended to be SQL safe; it's for
   // displaying in error messages. Nonetheless if you find issues with
   // SQL compatibility, please send a PR or issue.
+
   // Ref: https://www.postgresql.org/docs/current/static/sql-syntax-lexical.html#SQL-BACKSLASH-TABLE
   const escape = str => str.replace(/['\\\b\f\n\r\t]/g, chr => ({
     "\b": "\\b",
@@ -189,10 +149,11 @@ function sqlCommentByAddingTags(entity, tagsToAdd) {
     "\n": "\\n",
     "\r": "\\r",
     "\t": "\\t"
-  })[chr] || "\\" + chr); // tagsToAdd is here twice to ensure that the keys in tagsToAdd come first, but that they also "win" any conflicts.
-
+  })[chr] || "\\" + chr);
 
-  const tags = { ...tagsToAdd,
+  // tagsToAdd is here twice to ensure that the keys in tagsToAdd come first, but that they also "win" any conflicts.
+  const tags = {
+    ...tagsToAdd,
     ...entity.tags,
     ...tagsToAdd
   };
@@ -208,10 +169,8 @@ function sqlCommentByAddingTags(entity, tagsToAdd) {
   }, []).join("\\n");
   const commentValue = `E'${tagsSql}${description ? "\\n" + escape(description) : ""}'`;
   let sqlThing;
-
   if (entity.kind === "class") {
     const identifier = `"${entity.namespaceName}"."${entity.name}"`;
-
     if (entity.classKind === "r") {
       sqlThing = `TABLE ${identifier}`;
     } else if (entity.classKind === "v") {
@@ -233,10 +192,8 @@ function sqlCommentByAddingTags(entity, tagsToAdd) {
   } else {
     sqlThing = `UNKNOWN_ENTITY_PLEASE_SEND_A_PULL_REQUEST`;
   }
-
   return `COMMENT ON ${sqlThing} IS ${commentValue};`;
 }
-
 var PgBasicsPlugin = function PgBasicsPlugin(builder, {
   pgStrictFunctions = false,
   pgColumnFilter = defaultPgColumnFilter,
@@ -249,15 +206,12 @@ var PgBasicsPlugin = function PgBasicsPlugin(builder, {
   pgAugmentIntrospectionResults
 }) {
   let pgOmit = _omit.default;
-
   if (!pgIgnoreRBAC) {
     pgOmit = omitWithRBACChecks(pgOmit);
   }
-
   if (!pgIgnoreIndexes) {
     pgOmit = omitUnindexed(pgOmit, pgHideIndexWarnings);
   }
-
   builder.hook("build", build => {
     build.versions["graphile-build-pg"] = _package.version;
     build.liveCoordinator.registerProvider(new _PgLiveProvider.default());
@@ -287,55 +241,43 @@ var PgBasicsPlugin = function PgBasicsPlugin(builder, {
   builder.hook("inflection", (inflection, build) => {
     // TODO:v5: move this to postgraphile-core
     const oldBuiltin = inflection.builtin;
-
     inflection.builtin = function (name) {
       if (pgLegacyJsonUuid && name === "JSON") return "Json";
       if (pgLegacyJsonUuid && name === "UUID") return "Uuid";
       return oldBuiltin.call(this, name);
     };
-
     return build.extend(inflection, preventEmptyResult({
       // These helpers are passed GraphQL type names as strings
       conditionType(typeName) {
         return this.upperCamelCase(`${typeName}-condition`);
       },
-
       inputType(typeName) {
         return this.upperCamelCase(`${typeName}-input`);
       },
-
       rangeBoundType(typeName) {
         return this.upperCamelCase(`${typeName}-range-bound`);
       },
-
       rangeType(typeName) {
         return this.upperCamelCase(`${typeName}-range`);
       },
-
       patchType(typeName) {
         return this.upperCamelCase(`${typeName}-patch`);
       },
-
       baseInputType(typeName) {
         return this.upperCamelCase(`${typeName}-base-input`);
       },
-
       patchField(itemName) {
         return this.camelCase(`${itemName}-patch`);
       },
-
       orderByType(typeName) {
         return this.upperCamelCase(`${this.pluralize(typeName)}-order-by`);
       },
-
       edge(typeName) {
         return this.upperCamelCase(`${this.pluralize(typeName)}-edge`);
       },
-
       connection(typeName) {
         return this.upperCamelCase(`${this.pluralize(typeName)}-connection`);
       },
-
       // These helpers handle overrides via smart comments. They should only
       // be used in other inflectors, hence the underscore prefix.
       //
@@ -345,76 +287,63 @@ var PgBasicsPlugin = function PgBasicsPlugin(builder, {
       _functionName(proc) {
         return this.coerceToGraphQLName(proc.tags.name || proc.name);
       },
-
       _typeName(type) {
         // 'type' introspection result
         return this.coerceToGraphQLName(type.tags.name || type.name);
       },
-
       _tableName(table) {
         return this.coerceToGraphQLName(table.tags.name || table.type.tags.name || table.name);
       },
-
       _singularizedTableName(table) {
         return this.singularize(this._tableName(table)).replace(/.(?:(?:[_-]i|I)nput|(?:[_-]p|P)atch)$/, "$&_record");
       },
-
       _columnName(attr, _options) {
         return this.coerceToGraphQLName(attr.tags.name || attr.name);
       },
-
       // From here down, functions are passed database introspection results
       enumType(type) {
         if (type.tags.enumName) {
           return type.tags.enumName;
         }
-
         return this.upperCamelCase(this._typeName(type));
       },
-
       argument(name, index) {
         return this.coerceToGraphQLName(this.camelCase(name || `arg${index}`));
       },
-
       orderByEnum(columnName, ascending) {
         return this.constantCase(`${columnName}_${ascending ? "asc" : "desc"}`);
       },
-
       orderByColumnEnum(attr, ascending) {
         const columnName = this._columnName(attr, {
           skipRowId: true // Because we messed up 😔
-
         });
 
         return this.orderByEnum(columnName, ascending);
       },
-
       orderByComputedColumnEnum(pseudoColumnName, proc, table, ascending) {
         const columnName = this.computedColumn(pseudoColumnName, proc, table);
         return this.orderByEnum(columnName, ascending);
       },
-
       domainType(type) {
         return this.upperCamelCase(this._typeName(type));
       },
-
       enumName(inValue) {
         let value = inValue;
-
         if (value === "") {
           return "_EMPTY_";
-        } // Some enums use asterisks to signify wildcards - this might be for
+        }
+
+        // Some enums use asterisks to signify wildcards - this might be for
         // the whole item, or prefixes/suffixes, or even in the middle.  This
         // is provided on a best efforts basis, if it doesn't suit your
         // purposes then please pass a custom inflector as mentioned below.
+        value = value.replace(/\*/g, "_ASTERISK_").replace(/^(_?)_+ASTERISK/, "$1ASTERISK").replace(/ASTERISK_(_?)_*$/, "ASTERISK$1");
 
-
-        value = value.replace(/\*/g, "_ASTERISK_").replace(/^(_?)_+ASTERISK/, "$1ASTERISK").replace(/ASTERISK_(_?)_*$/, "ASTERISK$1"); // This is a best efforts replacement for common symbols that you
+        // This is a best efforts replacement for common symbols that you
         // might find in enums. Generally we only support enums that are
         // alphanumeric, if these replacements don't work for you, you should
         // pass a custom inflector that replaces this `enumName` method
         // with one of your own chosing.
-
         value = {
           // SQL comparison operators
           ">": "GREATER_THAN",
@@ -471,34 +400,26 @@ var PgBasicsPlugin = function PgBasicsPlugin(builder, {
         }[value] || value;
         return value;
       },
-
       tableNode(table) {
         return this.camelCase(this._singularizedTableName(table));
       },
-
       tableFieldName(table) {
         return this.camelCase(this._singularizedTableName(table));
       },
-
       allRows(table) {
         return this.camelCase(`all-${this.pluralize(this._singularizedTableName(table))}`);
       },
-
       allRowsSimple(table) {
         return this.camelCase(`all-${this.pluralize(this._singularizedTableName(table))}-list`);
       },
-
       functionMutationName(proc) {
         return this.camelCase(this._functionName(proc));
       },
-
       functionMutationResultFieldName(proc, gqlType, plural = false, outputArgNames = []) {
         if (proc.tags.resultFieldName) {
           return proc.tags.resultFieldName;
         }
-
         let name;
-
         if (outputArgNames.length === 1 && outputArgNames[0] !== "") {
           name = this.camelCase(outputArgNames[0]);
         } else if (gqlType.name === "Int") {
@@ -515,193 +436,145 @@ var PgBasicsPlugin = function PgBasicsPlugin(builder, {
         } else {
           name = this.camelCase(gqlType.name);
         }
-
         return plural ? this.pluralize(name) : name;
       },
-
       functionQueryName(proc) {
         return this.camelCase(this._functionName(proc));
       },
-
       functionQueryNameList(proc) {
         return this.camelCase(`${this._functionName(proc)}-list`);
       },
-
       functionPayloadType(proc) {
         return this.upperCamelCase(`${this._functionName(proc)}-payload`);
       },
-
       functionInputType(proc) {
         return this.upperCamelCase(`${this._functionName(proc)}-input`);
       },
-
       functionOutputFieldName(proc, outputArgName, index) {
         return this.argument(outputArgName, index);
       },
-
       tableType(table) {
         return this.upperCamelCase(this._singularizedTableName(table));
       },
-
       column(attr) {
         return this.camelCase(this._columnName(attr));
       },
-
       computedColumn(pseudoColumnName, proc, _table) {
         return proc.tags.fieldName || this.camelCase(pseudoColumnName);
       },
-
       computedColumnList(pseudoColumnName, proc, _table) {
         return proc.tags.fieldName ? proc.tags.fieldName + "List" : this.camelCase(`${pseudoColumnName}-list`);
       },
-
       singleRelationByKeys(detailedKeys, table, _foreignTable, constraint) {
         if (constraint.tags.fieldName) {
           return constraint.tags.fieldName;
         }
-
         return this.camelCase(`${this._singularizedTableName(table)}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}`);
       },
-
       singleRelationByKeysBackwards(detailedKeys, table, _foreignTable, constraint) {
         if (constraint.tags.foreignSingleFieldName) {
           return constraint.tags.foreignSingleFieldName;
         }
-
         if (constraint.tags.foreignFieldName) {
           return constraint.tags.foreignFieldName;
         }
-
         return this.singleRelationByKeys(detailedKeys, table, _foreignTable, constraint);
       },
-
       manyRelationByKeys(detailedKeys, table, _foreignTable, constraint) {
         if (constraint.tags.foreignFieldName) {
           return constraint.tags.foreignFieldName;
         }
-
         return this.camelCase(`${this.pluralize(this._singularizedTableName(table))}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}`);
       },
-
       manyRelationByKeysSimple(detailedKeys, table, _foreignTable, constraint) {
         if (constraint.tags.foreignSimpleFieldName) {
           return constraint.tags.foreignSimpleFieldName;
         }
-
         if (constraint.tags.foreignFieldName) {
           return constraint.tags.foreignFieldName;
         }
-
         return this.camelCase(`${this.pluralize(this._singularizedTableName(table))}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}-list`);
       },
-
       rowByUniqueKeys(detailedKeys, table, constraint) {
         if (constraint.tags.fieldName) {
           return constraint.tags.fieldName;
         }
-
         return this.camelCase(`${this._singularizedTableName(table)}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}`);
       },
-
       updateByKeys(detailedKeys, table, constraint) {
         if (constraint.tags.updateFieldName) {
           return constraint.tags.updateFieldName;
         }
-
         return this.camelCase(`update-${this._singularizedTableName(table)}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}`);
       },
-
       deleteByKeys(detailedKeys, table, constraint) {
         if (constraint.tags.deleteFieldName) {
           return constraint.tags.deleteFieldName;
         }
-
         return this.camelCase(`delete-${this._singularizedTableName(table)}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}`);
       },
-
       updateByKeysInputType(detailedKeys, table, constraint) {
         if (constraint.tags.updateFieldName) {
           return this.upperCamelCase(`${constraint.tags.updateFieldName}-input`);
         }
-
         return this.upperCamelCase(`update-${this._singularizedTableName(table)}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}-input`);
       },
-
       deleteByKeysInputType(detailedKeys, table, constraint) {
         if (constraint.tags.deleteFieldName) {
           return this.upperCamelCase(`${constraint.tags.deleteFieldName}-input`);
         }
-
         return this.upperCamelCase(`delete-${this._singularizedTableName(table)}-by-${detailedKeys.map(key => this.column(key)).join("-and-")}-input`);
       },
-
       updateNode(table) {
         return this.camelCase(`update-${this._singularizedTableName(table)}`);
       },
-
       deleteNode(table) {
         return this.camelCase(`delete-${this._singularizedTableName(table)}`);
       },
-
       deletedNodeId(table) {
         return this.camelCase(`deleted-${this.singularize(table.name)}-id`);
       },
-
       updateNodeInputType(table) {
         return this.upperCamelCase(`update-${this._singularizedTableName(table)}-input`);
       },
-
       deleteNodeInputType(table) {
         return this.upperCamelCase(`delete-${this._singularizedTableName(table)}-input`);
       },
-
       edgeField(table) {
         return this.camelCase(`${this._singularizedTableName(table)}-edge`);
       },
-
       recordFunctionReturnType(proc) {
         return proc.tags.resultTypeName || this.upperCamelCase(`${this._functionName(proc)}-record`);
       },
-
       recordFunctionConnection(proc) {
         return this.upperCamelCase(`${this._functionName(proc)}-connection`);
       },
-
       recordFunctionEdge(proc) {
         return this.upperCamelCase(`${this.singularize(this._functionName(proc))}-edge`);
       },
-
       scalarFunctionConnection(proc) {
         return this.upperCamelCase(`${this._functionName(proc)}-connection`);
       },
-
       scalarFunctionEdge(proc) {
         return this.upperCamelCase(`${this.singularize(this._functionName(proc))}-edge`);
       },
-
       createField(table) {
         return this.camelCase(`create-${this._singularizedTableName(table)}`);
       },
-
       createInputType(table) {
         return this.upperCamelCase(`create-${this._singularizedTableName(table)}-input`);
       },
-
       createPayloadType(table) {
         return this.upperCamelCase(`create-${this._singularizedTableName(table)}-payload`);
       },
-
       updatePayloadType(table) {
         return this.upperCamelCase(`update-${this._singularizedTableName(table)}-payload`);
       },
-
       deletePayloadType(table) {
         return this.upperCamelCase(`delete-${this._singularizedTableName(table)}-payload`);
       }
-
     }), "Default inflectors from PgBasicsPlugin. You can override these with `makeAddInflectorsPlugin(..., true)`.");
   }, ["PgBasics"]);
 };
-
 exports.default = PgBasicsPlugin;
 //# sourceMappingURL=PgBasicsPlugin.js.map