npm - graphile-simple-inflector - Versions diffs - 0.1.1 → 0.1.3 - Mend

graphile-simple-inflector 0.1.1 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/LICENSE CHANGED Viewed

@@ -1,6 +1,8 @@
 The MIT License (MIT)
-Copyright (c) 2020 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Dan Lynch <pyramation@gmail.com>
+Copyright (c) 2025 Hyperweb <developers@hyperweb.io>
+Copyright (c) 2020-present, Interweb, Inc.
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md CHANGED Viewed

@@ -1,13 +1,34 @@
-# graphile-simple-inflector [![Build Status](https://travis-ci.org/pyramation/graphile-simple-inflector.svg?branch=master)](https://travis-ci.org/pyramation/graphile-simple-inflector)
+# graphile-simple-inflector
+Simplified naming inflector for Graphile/PostGraphile. It shortens common field names (e.g. `tableByNodeId` → `table`) and makes pluralization behave more predictably for numeric suffixes.
+## Install
 ```sh
-npm install graphile-simple-inflector
+pnpm add graphile-simple-inflector
 ```
-## testing
+When using PostGraphile:
+```ts
+import PgSimpleInflector from 'graphile-simple-inflector';
+createPostGraphileSchema(pool, ['app_public'], {
+  appendPlugins: [PgSimpleInflector],
+  graphileBuildOptions: {
+    pgSimplifyPatch: true,
+    pgSimplifyAllRows: true
+  }
+});
+```
+## Testing
+Tests expect a running PostgreSQL instance (see `utils/env.ts` for defaults). Seed the test database with the provided fixtures or let the test harness create them automatically:
 ```sh
-createdb test_database
-psql test_database < sql/roles.sql
-psql test_database < sql/test.sql
-```
+psql -U postgres -f sql/roles.sql postgres
+pnpm test --filter graphile-simple-inflector
+```
+The included SQL under `sql/` matches the original package’s fixtures.

package/index.js ADDED Viewed

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgSimpleInflector = void 0;
+const fixCapitalisedPlural = (fn) => function capitalisedPlural(str) {
+    const original = fn.call(this, str);
+    return original.replace(/[0-9]S(?=[A-Z]|$)/g, (match) => match.toLowerCase());
+};
+const fixChangePlural = (fn) => function changePlural(str) {
+    const matches = str.match(/([A-Z]|_[a-z0-9])[a-z0-9]*_*$/);
+    const index = matches ? (matches.index ?? 0) + matches[1].length - 1 : 0;
+    const suffixMatches = str.match(/_*$/);
+    const suffixIndex = suffixMatches && suffixMatches.index !== undefined ? suffixMatches.index : str.length;
+    const prefix = str.slice(0, index);
+    const word = str.slice(index, suffixIndex);
+    const suffix = str.slice(suffixIndex);
+    return `${prefix}${fn.call(this, word)}${suffix}`;
+};
+const DEFAULT_NODE_ID = 'nodeId';
+const PgSimpleInflector = (builder, { pgSimpleCollections, pgOmitListSuffix, pgSimplifyPatch = true, pgSimplifyAllRows = true, pgShortPk = true, pgSimplifyMultikeyRelations = true, pgSimplifyOppositeBaseNames = true, nodeIdFieldName = DEFAULT_NODE_ID, } = {}) => {
+    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) => {
+        const inflection = {
+            ...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) {
+                if (!baseName)
+                    return false;
+                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) ?? null;
+                }
+                if (pgSimplifyMultikeyRelations) {
+                    const columnNames = detailedKeys.map((key) => this._columnName(key));
+                    const baseNames = columnNames.map((columnName) => this.getBaseName?.(columnName) ?? null);
+                    // Check none are null
+                    if (baseNames.every((n) => n)) {
+                        return baseNames.join('-');
+                    }
+                }
+                return null;
+            },
+            ...(pgSimplifyPatch
+                ? {
+                    patchField() {
+                        return 'patch';
+                    },
+                }
+                : {}),
+            ...(pgSimplifyAllRows
+                ? {
+                    allRows(table) {
+                        return this.camelCase(this.distinctPluralize(this._singularizedTableName(table)) + connectionSuffix);
+                    },
+                    allRowsSimple(table) {
+                        return this.camelCase(this.distinctPluralize(this._singularizedTableName(table)) + listSuffix);
+                    },
+                }
+                : {}),
+            computedColumn(pseudoColumnName, proc) {
+                return proc.tags.fieldName
+                    ? `${proc.tags.fieldName}${proc.returnsSet ? ConnectionSuffix : ''}`
+                    : this.camelCase(pseudoColumnName + (proc.returnsSet ? connectionSuffix : ''));
+            },
+            computedColumnList(pseudoColumnName, proc) {
+                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 (baseName && 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);
+                if (oppositeBaseName) {
+                    return this.camelCase(`${oppositeBaseName}-${this._singularizedTableName(table)}`);
+                }
+                if (baseName && 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);
+                if (constraint.classId === constraint.foreignClassId) {
+                    if (baseName && this.baseNameMatches?.(baseName, table.name)) {
+                        return null;
+                    }
+                }
+                if (oppositeBaseName) {
+                    return this.camelCase(`${oppositeBaseName}-${this.distinctPluralize(this._singularizedTableName(table))}`);
+                }
+                if (baseName && 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') {
+                            // Primary key, shorten!
+                            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`);
+                    },
+                }
+                : {}),
+        };
+        return inflection;
+    });
+};
+exports.PgSimpleInflector = PgSimpleInflector;
+exports.default = exports.PgSimpleInflector;

package/package.json CHANGED Viewed

@@ -1,36 +1,37 @@
 {
   "name": "graphile-simple-inflector",
-  "version": "0.1.1",
-  "description": "simple inflector",
+  "version": "0.1.3",
+  "description": "Simple inflector plugin for Graphile/PostGraphile",
   "author": "Dan Lynch <pyramation@gmail.com>",
-  "homepage": "https://github.com/pyramation/graphile-simple-inflector#readme",
+  "homepage": "https://github.com/launchql/launchql",
   "license": "SEE LICENSE IN LICENSE",
-  "main": "main/index.js",
-  "module": "module/index.js",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
   "directories": {
     "lib": "src",
     "test": "__tests__"
   },
   "files": [
-    "main",
-    "module"
+    "dist"
   ],
   "scripts": {
-    "build:main": "BABEL_ENV=production babel src --out-dir main --delete-dir-on-start",
-    "build:module": "MODULE=true babel src --out-dir module --delete-dir-on-start",
-    "build": "npm run build:module && npm run build:main",
-    "prepublish": "npm run build",
-    "lint": "eslint src --fix",
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "prepack": "npm run build",
+    "build": "npm run clean; tsc -p tsconfig.json; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc -p tsconfig.json --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "lint": "eslint . --fix",
     "test": "jest",
-    "test:watch": "jest --watch",
-    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+    "test:watch": "jest --watch"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "directory": "dist"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pyramation/graphile-simple-inflector"
+    "url": "https://github.com/launchql/launchql"
   },
   "keywords": [
     "graphile",
@@ -38,37 +39,19 @@
     "postgres",
     "graphql",
     "inflection",
-    "plugin"
+    "plugin",
+    "launchql"
   ],
   "bugs": {
-    "url": "https://github.com/pyramation/graphile-simple-inflector/issues"
+    "url": "https://github.com/launchql/launchql/issues"
   },
   "devDependencies": {
-    "@babel/cli": "7.8.4",
-    "@babel/core": "7.8.4",
-    "@babel/plugin-proposal-class-properties": "7.8.3",
-    "@babel/plugin-proposal-export-default-from": "7.8.3",
-    "@babel/plugin-proposal-object-rest-spread": "7.9.6",
-    "@babel/plugin-transform-runtime": "7.9.6",
-    "@babel/preset-env": "7.9.6",
-    "@babel/preset-react": "7.9.4",
-    "babel-core": "7.0.0-bridge.0",
-    "babel-eslint": "10.0.3",
-    "babel-jest": "25.1.0",
-    "babel-plugin-macros": "2.8.0",
-    "eslint": "6.8.0",
-    "eslint-config-prettier": "^6.10.0",
-    "eslint-config-react-app": "5.2.0",
-    "eslint-plugin-prettier": "^3.1.2",
-    "eslint-plugin-react": "^7.18.3",
-    "eslint-plugin-react-hooks": "4.0.0",
-    "graphile-test": "^0.1.0",
-    "jest": "^24.5.0",
-    "jest-in-case": "^1.0.2",
-    "prettier": "^1.19.1",
-    "regenerator-runtime": "^0.13.2"
+    "graphile-test": "^2.8.4",
+    "graphql-tag": "2.12.6",
+    "pgsql-test": "^2.14.7"
   },
   "dependencies": {
-    "@babel/runtime": "^7.4.2"
-  }
+    "graphile-build": "^4.14.1"
+  },
+  "gitHead": "4cd832ebee39d7be9375340e8e3283692d15b464"
 }

package/main/index.js DELETED Viewed

@@ -1,402 +0,0 @@
-"use strict";
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PgSimpleInflector = PgSimpleInflector;
-exports["default"] = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/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) { (0, _defineProperty2["default"])(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) {
-    var original = fn.call(this, str);
-    return original.replace(/[0-9]S(?=[A-Z]|$)/g, function (match) {
-      return match.toLowerCase();
-    });
-  };
-}
-function fixChangePlural(fn) {
-  return function (str) {
-    var matches = str.match(/([A-Z]|_[a-z0-9])[a-z0-9]*_*$/);
-    var index = matches ? matches.index + matches[1].length - 1 : 0;
-    var suffixMatches = str.match(/_*$/);
-    var suffixIndex = suffixMatches.index;
-    var prefix = str.substr(0, index);
-    var word = str.substr(index, suffixIndex - index);
-    var suffix = str.substr(suffixIndex);
-    return "".concat(prefix).concat(fn.call(this, word)).concat(suffix);
-  };
-}
-function PgSimpleInflector(builder, _ref) {
-  var pgSimpleCollections = _ref.pgSimpleCollections,
-      pgOmitListSuffix = _ref.pgOmitListSuffix,
-      _ref$pgSimplifyPatch = _ref.pgSimplifyPatch,
-      pgSimplifyPatch = _ref$pgSimplifyPatch === void 0 ? true : _ref$pgSimplifyPatch,
-      _ref$pgSimplifyAllRow = _ref.pgSimplifyAllRows,
-      pgSimplifyAllRows = _ref$pgSimplifyAllRow === void 0 ? true : _ref$pgSimplifyAllRow,
-      _ref$pgShortPk = _ref.pgShortPk,
-      pgShortPk = _ref$pgShortPk === void 0 ? true : _ref$pgShortPk,
-      _ref$pgSimplifyMultik = _ref.pgSimplifyMultikeyRelations,
-      pgSimplifyMultikeyRelations = _ref$pgSimplifyMultik === void 0 ? true : _ref$pgSimplifyMultik,
-      _ref$pgSimplifyOpposi = _ref.pgSimplifyOppositeBaseNames,
-      pgSimplifyOppositeBaseNames = _ref$pgSimplifyOpposi === void 0 ? true : _ref$pgSimplifyOpposi,
-      _ref$nodeIdFieldName = _ref.nodeIdFieldName,
-      nodeIdFieldName = _ref$nodeIdFieldName === void 0 ? 'nodeId' : _ref$nodeIdFieldName;
-  var hasConnections = pgSimpleCollections !== 'only';
-  var 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.');
-  }
-  var connectionSuffix = pgOmitListSuffix ? '-connection' : '';
-  var ConnectionSuffix = pgOmitListSuffix ? 'Connection' : '';
-  var listSuffix = pgOmitListSuffix ? '' : '-list';
-  var ListSuffix = pgOmitListSuffix ? '' : 'List';
-  builder.hook('inflection', function (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: function distinctPluralize(str) {
-        var singular = this.singularize(str);
-        var 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: function deletedNodeId(table) {
-        return this.camelCase("deleted-".concat(this.singularize(table.name), "-").concat(nodeIdFieldName));
-      },
-      getBaseName: function getBaseName(columnName) {
-        var matches = columnName.match(/^(.+?)(_row_id|_id|_uuid|_fk|_pk|RowId|Id|Uuid|UUID|Fk|Pk)$/);
-        if (matches) {
-          return matches[1];
-        }
-        return null;
-      },
-      baseNameMatches: function baseNameMatches(baseName, otherName) {
-        var singularizedName = this.singularize(otherName);
-        return baseName === singularizedName;
-      },
-      baseNameMatchesAny: function baseNameMatchesAny(baseName, otherName) {
-        return this.singularize(baseName) === this.singularize(otherName);
-      },
-      /* This is a good method to override. */
-      getOppositeBaseName: function 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: function getBaseNameFromKeys(detailedKeys) {
-        var _this = this;
-        if (detailedKeys.length === 1) {
-          var key = detailedKeys[0];
-          var columnName = this._columnName(key);
-          return this.getBaseName(columnName);
-        }
-        if (pgSimplifyMultikeyRelations) {
-          var columnNames = detailedKeys.map(function (key) {
-            return _this._columnName(key);
-          });
-          var baseNames = columnNames.map(function (columnName) {
-            return _this.getBaseName(columnName);
-          }); // Check none are null
-          if (baseNames.every(function (n) {
-            return n;
-          })) {
-            return baseNames.join('-');
-          }
-        }
-        return null;
-      }
-    }, pgSimplifyPatch ? {
-      patchField: function patchField() {
-        return 'patch';
-      }
-    } : null), pgSimplifyAllRows ? {
-      allRows: function allRows(table) {
-        return this.camelCase(this.distinctPluralize(this._singularizedTableName(table)) + connectionSuffix);
-      },
-      allRowsSimple: function allRowsSimple(table) {
-        return this.camelCase(this.distinctPluralize(this._singularizedTableName(table)) + listSuffix);
-      }
-    } : null), {}, {
-      computedColumn: function computedColumn(pseudoColumnName, proc, _table) {
-        return proc.tags.fieldName ? proc.tags.fieldName + (proc.returnsSet ? ConnectionSuffix : '') : this.camelCase(pseudoColumnName + (proc.returnsSet ? connectionSuffix : ''));
-      },
-      computedColumnList: function computedColumnList(pseudoColumnName, proc, _table) {
-        return proc.tags.fieldName ? proc.tags.fieldName + ListSuffix : this.camelCase(pseudoColumnName + listSuffix);
-      },
-      singleRelationByKeys: function singleRelationByKeys(detailedKeys, table, _foreignTable, constraint) {
-        if (constraint.tags.fieldName) {
-          return constraint.tags.fieldName;
-        }
-        var 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("".concat(this._singularizedTableName(table)));
-        }
-        return oldInflection.singleRelationByKeys(detailedKeys, table, _foreignTable, constraint);
-      },
-      singleRelationByKeysBackwards: function singleRelationByKeysBackwards(detailedKeys, table, foreignTable, constraint) {
-        if (constraint.tags.foreignSingleFieldName) {
-          return constraint.tags.foreignSingleFieldName;
-        }
-        if (constraint.tags.foreignFieldName) {
-          return constraint.tags.foreignFieldName;
-        }
-        var baseName = this.getBaseNameFromKeys(detailedKeys);
-        var 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("".concat(oppositeBaseName, "-").concat(this._singularizedTableName(table)));
-        }
-        if (this.baseNameMatches(baseName, foreignTable.name)) {
-          return this.camelCase("".concat(this._singularizedTableName(table)));
-        }
-        return oldInflection.singleRelationByKeysBackwards(detailedKeys, table, foreignTable, constraint);
-      },
-      _manyRelationByKeysBase: function _manyRelationByKeysBase(detailedKeys, table, _foreignTable, _constraint) {
-        var baseName = this.getBaseNameFromKeys(detailedKeys);
-        var oppositeBaseName = baseName && this.getOppositeBaseName(baseName); // added
-        if (_constraint.classId === _constraint.foreignClassId) {
-          if (this.baseNameMatches(baseName, table.name)) {
-            return null;
-          }
-        }
-        if (oppositeBaseName) {
-          return this.camelCase("".concat(oppositeBaseName, "-").concat(this.distinctPluralize(this._singularizedTableName(table))));
-        }
-        if (this.baseNameMatches(baseName, _foreignTable.name)) {
-          return this.camelCase("".concat(this.distinctPluralize(this._singularizedTableName(table))));
-        }
-        return null;
-      },
-      manyRelationByKeys: function manyRelationByKeys(detailedKeys, table, foreignTable, constraint) {
-        if (constraint.tags.foreignFieldName) {
-          if (constraint.tags.foreignSimpleFieldName) {
-            return constraint.tags.foreignFieldName;
-          } else {
-            return constraint.tags.foreignFieldName + ConnectionSuffix;
-          }
-        }
-        var base = this._manyRelationByKeysBase(detailedKeys, table, foreignTable, constraint);
-        if (base) {
-          return base + ConnectionSuffix;
-        }
-        return oldInflection.manyRelationByKeys(detailedKeys, table, foreignTable, constraint) + ConnectionSuffix;
-      },
-      manyRelationByKeysSimple: function manyRelationByKeysSimple(detailedKeys, table, foreignTable, constraint) {
-        if (constraint.tags.foreignSimpleFieldName) {
-          return constraint.tags.foreignSimpleFieldName;
-        }
-        if (constraint.tags.foreignFieldName) {
-          return constraint.tags.foreignFieldName + ListSuffix;
-        }
-        var base = this._manyRelationByKeysBase(detailedKeys, table, foreignTable, constraint);
-        if (base) {
-          return base + ListSuffix;
-        }
-        return oldInflection.manyRelationByKeys(detailedKeys, table, foreignTable, constraint) + ListSuffix;
-      },
-      functionQueryName: function functionQueryName(proc) {
-        return this.camelCase(this._functionName(proc) + (proc.returnsSet ? connectionSuffix : ''));
-      },
-      functionQueryNameList: function functionQueryNameList(proc) {
-        return this.camelCase(this._functionName(proc) + listSuffix);
-      }
-    }, pgShortPk ? {
-      tableNode: function tableNode(table) {
-        return this.camelCase("".concat(this._singularizedTableName(table), "-by-").concat(nodeIdFieldName));
-      },
-      rowByUniqueKeys: function rowByUniqueKeys(detailedKeys, table, constraint) {
-        var _this2 = this;
-        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("".concat(this._singularizedTableName(table), "-by-").concat(detailedKeys.map(function (key) {
-            return _this2.column(key);
-          }).join('-and-')));
-        }
-      },
-      updateByKeys: function updateByKeys(detailedKeys, table, constraint) {
-        var _this3 = this;
-        if (constraint.tags.updateFieldName) {
-          return constraint.tags.updateFieldName;
-        }
-        if (constraint.type === 'p') {
-          return this.camelCase("update-".concat(this._singularizedTableName(table)));
-        } else {
-          return this.camelCase("update-".concat(this._singularizedTableName(table), "-by-").concat(detailedKeys.map(function (key) {
-            return _this3.column(key);
-          }).join('-and-')));
-        }
-      },
-      deleteByKeys: function deleteByKeys(detailedKeys, table, constraint) {
-        var _this4 = this;
-        if (constraint.tags.deleteFieldName) {
-          return constraint.tags.deleteFieldName;
-        }
-        if (constraint.type === 'p') {
-          // Primary key, shorten!
-          return this.camelCase("delete-".concat(this._singularizedTableName(table)));
-        } else {
-          return this.camelCase("delete-".concat(this._singularizedTableName(table), "-by-").concat(detailedKeys.map(function (key) {
-            return _this4.column(key);
-          }).join('-and-')));
-        }
-      },
-      updateByKeysInputType: function updateByKeysInputType(detailedKeys, table, constraint) {
-        var _this5 = this;
-        if (constraint.tags.updateFieldName) {
-          return this.upperCamelCase("".concat(constraint.tags.updateFieldName, "-input"));
-        }
-        if (constraint.type === 'p') {
-          // Primary key, shorten!
-          return this.upperCamelCase("update-".concat(this._singularizedTableName(table), "-input"));
-        } else {
-          return this.upperCamelCase("update-".concat(this._singularizedTableName(table), "-by-").concat(detailedKeys.map(function (key) {
-            return _this5.column(key);
-          }).join('-and-'), "-input"));
-        }
-      },
-      deleteByKeysInputType: function deleteByKeysInputType(detailedKeys, table, constraint) {
-        var _this6 = this;
-        if (constraint.tags.deleteFieldName) {
-          return this.upperCamelCase("".concat(constraint.tags.deleteFieldName, "-input"));
-        }
-        if (constraint.type === 'p') {
-          // Primary key, shorten!
-          return this.upperCamelCase("delete-".concat(this._singularizedTableName(table), "-input"));
-        } else {
-          return this.upperCamelCase("delete-".concat(this._singularizedTableName(table), "-by-").concat(detailedKeys.map(function (key) {
-            return _this6.column(key);
-          }).join('-and-'), "-input"));
-        }
-      },
-      updateNode: function updateNode(table) {
-        return this.camelCase("update-".concat(this._singularizedTableName(table), "-by-").concat(nodeIdFieldName));
-      },
-      deleteNode: function deleteNode(table) {
-        return this.camelCase("delete-".concat(this._singularizedTableName(table), "-by-").concat(nodeIdFieldName));
-      },
-      updateNodeInputType: function updateNodeInputType(table) {
-        return this.upperCamelCase("update-".concat(this._singularizedTableName(table), "-by-").concat(nodeIdFieldName, "-input"));
-      },
-      deleteNodeInputType: function deleteNodeInputType(table) {
-        return this.upperCamelCase("delete-".concat(this._singularizedTableName(table), "-by-").concat(nodeIdFieldName, "-input"));
-      }
-    } : null);
-  });
-}
-var _default = PgSimpleInflector;
-exports["default"] = _default;

package/module/index.js DELETED Viewed

@@ -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;