graphile-simple-inflector 0.1.1 → 0.1.4

package/index.js

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

@@ -1,36 +1,30 @@
 {
   "name": "graphile-simple-inflector",
-  "version": "0.1.1",
-  "description": "simple inflector",
+  "version": "0.1.4",
+  "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",
-  "directories": {
-    "lib": "src",
-    "test": "__tests__"
-  },
-  "files": [
-    "main",
-    "module"
-  ],
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
   "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",
+    "clean": "makage clean",
+    "copy": "makage assets",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "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 +32,20 @@
     "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.5",
+    "graphql-tag": "2.12.6",
+    "makage": "^0.1.6",
+    "pgsql-test": "^2.14.8"
   },
   "dependencies": {
-    "@babel/runtime": "^7.4.2"
-  }
+    "graphile-build": "^4.14.1"
+  },
+  "gitHead": "e4643c07b6a961b964bbb132308366fc549504a1"
 }