graphile-simple-inflector 0.1.1 → 0.1.4

package/module/index.js

@@ -1,384 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-// https://raw.githubusercontent.com/graphile/pg-simplify-inflector/master/index.js
-function fixCapitalisedPlural(fn) {
-  return function (str) {
-    const original = fn.call(this, str);
-    return original.replace(/[0-9]S(?=[A-Z]|$)/g, match => match.toLowerCase());
-  };
-}
-
-function fixChangePlural(fn) {
-  return function (str) {
-    const matches = str.match(/([A-Z]|_[a-z0-9])[a-z0-9]*_*$/);
-    const index = matches ? matches.index + matches[1].length - 1 : 0;
-    const suffixMatches = str.match(/_*$/);
-    const suffixIndex = suffixMatches.index;
-    const prefix = str.substr(0, index);
-    const word = str.substr(index, suffixIndex - index);
-    const suffix = str.substr(suffixIndex);
-    return `${prefix}${fn.call(this, word)}${suffix}`;
-  };
-}
-
-export function PgSimpleInflector(builder, {
-  pgSimpleCollections,
-  pgOmitListSuffix,
-  pgSimplifyPatch = true,
-  pgSimplifyAllRows = true,
-  pgShortPk = true,
-  pgSimplifyMultikeyRelations = true,
-  pgSimplifyOppositeBaseNames = true,
-  nodeIdFieldName = 'nodeId'
-}) {
-  const hasConnections = pgSimpleCollections !== 'only';
-  const hasSimpleCollections = pgSimpleCollections === 'only' || pgSimpleCollections === 'both';
-
-  if (hasSimpleCollections && !hasConnections && pgOmitListSuffix !== true && pgOmitListSuffix !== false) {
-    // eslint-disable-next-line no-console
-    console.warn('You can simplify the inflector further by adding `{graphileBuildOptions: {pgOmitListSuffix: true}}` to the options passed to PostGraphile, however be aware that doing so will mean that later enabling relay connections will be a breaking change. To dismiss this message, set `pgOmitListSuffix` to false instead.');
-  }
-
-  const connectionSuffix = pgOmitListSuffix ? '-connection' : '';
-  const ConnectionSuffix = pgOmitListSuffix ? 'Connection' : '';
-  const listSuffix = pgOmitListSuffix ? '' : '-list';
-  const ListSuffix = pgOmitListSuffix ? '' : 'List';
-  builder.hook('inflection', oldInflection => {
-    return _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, oldInflection), {}, {
-      /*
-       * This solves the issue with `blah-table1s` becoming `blahTable1S`
-       * (i.e. the capital S at the end) or `table1-connection becoming `Table1SConnection`
-       */
-      camelCase: fixCapitalisedPlural(oldInflection.camelCase),
-      upperCamelCase: fixCapitalisedPlural(oldInflection.upperCamelCase),
-
-      /*
-       * Pluralize/singularize only supports single words, so only run
-       * on the final segment of a name.
-       */
-      pluralize: fixChangePlural(oldInflection.pluralize),
-      singularize: fixChangePlural(oldInflection.singularize),
-
-      distinctPluralize(str) {
-        const singular = this.singularize(str);
-        const plural = this.pluralize(singular);
-
-        if (singular !== plural) {
-          return plural;
-        }
-
-        if (plural.endsWith('ch') || plural.endsWith('s') || plural.endsWith('sh') || plural.endsWith('x') || plural.endsWith('z')) {
-          return plural + 'es';
-        } else if (plural.endsWith('y')) {
-          return plural.slice(0, -1) + 'ies';
-        } else {
-          return plural + 's';
-        }
-      },
-
-      // Fix a naming bug
-      deletedNodeId(table) {
-        return this.camelCase(`deleted-${this.singularize(table.name)}-${nodeIdFieldName}`);
-      },
-
-      getBaseName(columnName) {
-        const matches = columnName.match(/^(.+?)(_row_id|_id|_uuid|_fk|_pk|RowId|Id|Uuid|UUID|Fk|Pk)$/);
-
-        if (matches) {
-          return matches[1];
-        }
-
-        return null;
-      },
-
-      baseNameMatches(baseName, otherName) {
-        const singularizedName = this.singularize(otherName);
-        return baseName === singularizedName;
-      },
-
-      baseNameMatchesAny(baseName, otherName) {
-        return this.singularize(baseName) === this.singularize(otherName);
-      },
-
-      /* This is a good method to override. */
-      getOppositeBaseName(baseName) {
-        return pgSimplifyOppositeBaseNames && ({
-          /*
-           * Changes to this list are breaking changes and will require a
-           * major version update, so we need to group as many together as
-           * possible! Rather than sending a PR, please look for an open
-           * issue called something like "Add more opposites" (if there isn't
-           * one then please open it) and add your suggestions to the GitHub
-           * comments.
-           */
-          // NOTE: reason to be careful using this:
-          // field names to take into account this particular case (e.g. events with event.parent_id could not have parent OR child fields)
-          inviter: 'invitee',
-          parent: 'child',
-          child: 'parent',
-          owner: 'owned',
-          author: 'authored',
-          editor: 'edited',
-          reviewer: 'reviewed'
-        }[baseName] || null);
-      },
-
-      getBaseNameFromKeys(detailedKeys) {
-        if (detailedKeys.length === 1) {
-          const key = detailedKeys[0];
-
-          const columnName = this._columnName(key);
-
-          return this.getBaseName(columnName);
-        }
-
-        if (pgSimplifyMultikeyRelations) {
-          const columnNames = detailedKeys.map(key => this._columnName(key));
-          const baseNames = columnNames.map(columnName => this.getBaseName(columnName)); // Check none are null
-
-          if (baseNames.every(n => n)) {
-            return baseNames.join('-');
-          }
-        }
-
-        return null;
-      }
-
-    }, pgSimplifyPatch ? {
-      patchField() {
-        return 'patch';
-      }
-
-    } : null), pgSimplifyAllRows ? {
-      allRows(table) {
-        return this.camelCase(this.distinctPluralize(this._singularizedTableName(table)) + connectionSuffix);
-      },
-
-      allRowsSimple(table) {
-        return this.camelCase(this.distinctPluralize(this._singularizedTableName(table)) + listSuffix);
-      }
-
-    } : null), {}, {
-      computedColumn(pseudoColumnName, proc, _table) {
-        return proc.tags.fieldName ? proc.tags.fieldName + (proc.returnsSet ? ConnectionSuffix : '') : this.camelCase(pseudoColumnName + (proc.returnsSet ? connectionSuffix : ''));
-      },
-
-      computedColumnList(pseudoColumnName, proc, _table) {
-        return proc.tags.fieldName ? proc.tags.fieldName + ListSuffix : this.camelCase(pseudoColumnName + listSuffix);
-      },
-
-      singleRelationByKeys(detailedKeys, table, _foreignTable, constraint) {
-        if (constraint.tags.fieldName) {
-          return constraint.tags.fieldName;
-        }
-
-        const baseName = this.getBaseNameFromKeys(detailedKeys);
-
-        if (constraint.classId === constraint.foreignClassId) {
-          if (this.baseNameMatchesAny(baseName, table.name)) {
-            return oldInflection.singleRelationByKeys(detailedKeys, table, _foreignTable, constraint);
-          }
-        }
-
-        if (baseName) {
-          return this.camelCase(baseName);
-        }
-
-        if (this.baseNameMatches(baseName, table.name)) {
-          return this.camelCase(`${this._singularizedTableName(table)}`);
-        }
-
-        return oldInflection.singleRelationByKeys(detailedKeys, table, _foreignTable, constraint);
-      },
-
-      singleRelationByKeysBackwards(detailedKeys, table, foreignTable, constraint) {
-        if (constraint.tags.foreignSingleFieldName) {
-          return constraint.tags.foreignSingleFieldName;
-        }
-
-        if (constraint.tags.foreignFieldName) {
-          return constraint.tags.foreignFieldName;
-        }
-
-        const baseName = this.getBaseNameFromKeys(detailedKeys);
-        const oppositeBaseName = baseName && this.getOppositeBaseName(baseName); // added
-        // if (constraint.classId === constraint.foreignClassId) {
-        //   if (this.baseNameMatches(baseName, foreignTable.name)) {
-        //     return oldInflection.singleRelationByKeysBackwards(
-        //       detailedKeys,
-        //       table,
-        //       foreignTable,
-        //       constraint
-        //     );
-        //   }
-        // }
-
-        if (oppositeBaseName) {
-          return this.camelCase(`${oppositeBaseName}-${this._singularizedTableName(table)}`);
-        }
-
-        if (this.baseNameMatches(baseName, foreignTable.name)) {
-          return this.camelCase(`${this._singularizedTableName(table)}`);
-        }
-
-        return oldInflection.singleRelationByKeysBackwards(detailedKeys, table, foreignTable, constraint);
-      },
-
-      _manyRelationByKeysBase(detailedKeys, table, _foreignTable, _constraint) {
-        const baseName = this.getBaseNameFromKeys(detailedKeys);
-        const oppositeBaseName = baseName && this.getOppositeBaseName(baseName); // added
-
-        if (_constraint.classId === _constraint.foreignClassId) {
-          if (this.baseNameMatches(baseName, table.name)) {
-            return null;
-          }
-        }
-
-        if (oppositeBaseName) {
-          return this.camelCase(`${oppositeBaseName}-${this.distinctPluralize(this._singularizedTableName(table))}`);
-        }
-
-        if (this.baseNameMatches(baseName, _foreignTable.name)) {
-          return this.camelCase(`${this.distinctPluralize(this._singularizedTableName(table))}`);
-        }
-
-        return null;
-      },
-
-      manyRelationByKeys(detailedKeys, table, foreignTable, constraint) {
-        if (constraint.tags.foreignFieldName) {
-          if (constraint.tags.foreignSimpleFieldName) {
-            return constraint.tags.foreignFieldName;
-          } else {
-            return constraint.tags.foreignFieldName + ConnectionSuffix;
-          }
-        }
-
-        const base = this._manyRelationByKeysBase(detailedKeys, table, foreignTable, constraint);
-
-        if (base) {
-          return base + ConnectionSuffix;
-        }
-
-        return oldInflection.manyRelationByKeys(detailedKeys, table, foreignTable, constraint) + ConnectionSuffix;
-      },
-
-      manyRelationByKeysSimple(detailedKeys, table, foreignTable, constraint) {
-        if (constraint.tags.foreignSimpleFieldName) {
-          return constraint.tags.foreignSimpleFieldName;
-        }
-
-        if (constraint.tags.foreignFieldName) {
-          return constraint.tags.foreignFieldName + ListSuffix;
-        }
-
-        const base = this._manyRelationByKeysBase(detailedKeys, table, foreignTable, constraint);
-
-        if (base) {
-          return base + ListSuffix;
-        }
-
-        return oldInflection.manyRelationByKeys(detailedKeys, table, foreignTable, constraint) + ListSuffix;
-      },
-
-      functionQueryName(proc) {
-        return this.camelCase(this._functionName(proc) + (proc.returnsSet ? connectionSuffix : ''));
-      },
-
-      functionQueryNameList(proc) {
-        return this.camelCase(this._functionName(proc) + listSuffix);
-      }
-
-    }, pgShortPk ? {
-      tableNode(table) {
-        return this.camelCase(`${this._singularizedTableName(table)}-by-${nodeIdFieldName}`);
-      },
-
-      rowByUniqueKeys(detailedKeys, table, constraint) {
-        if (constraint.tags.fieldName) {
-          return constraint.tags.fieldName;
-        }
-
-        if (constraint.type === 'p') {
-          // Primary key, shorten!
-          return this.camelCase(this._singularizedTableName(table));
-        } else {
-          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;
-        }
-
-        if (constraint.type === 'p') {
-          return this.camelCase(`update-${this._singularizedTableName(table)}`);
-        } else {
-          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;
-        }
-
-        if (constraint.type === 'p') {
-          // Primary key, shorten!
-          return this.camelCase(`delete-${this._singularizedTableName(table)}`);
-        } else {
-          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`);
-        }
-
-        if (constraint.type === 'p') {
-          // Primary key, shorten!
-          return this.upperCamelCase(`update-${this._singularizedTableName(table)}-input`);
-        } else {
-          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`);
-        }
-
-        if (constraint.type === 'p') {
-          // Primary key, shorten!
-          return this.upperCamelCase(`delete-${this._singularizedTableName(table)}-input`);
-        } else {
-          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)}-by-${nodeIdFieldName}`);
-      },
-
-      deleteNode(table) {
-        return this.camelCase(`delete-${this._singularizedTableName(table)}-by-${nodeIdFieldName}`);
-      },
-
-      updateNodeInputType(table) {
-        return this.upperCamelCase(`update-${this._singularizedTableName(table)}-by-${nodeIdFieldName}-input`);
-      },
-
-      deleteNodeInputType(table) {
-        return this.upperCamelCase(`delete-${this._singularizedTableName(table)}-by-${nodeIdFieldName}-input`);
-      }
-
-    } : null);
-  });
-}
-export default PgSimpleInflector;