@haathie/postgraphile-replace-types 0.1.0

package/lib/index.d.ts

@@ -0,0 +1 @@
+export declare const ReplaceTypesPlugin: GraphileConfig.Plugin;

package/lib/index.js

@@ -0,0 +1,98 @@
+function wrapOutputType(originalType, replacementType, { graphql: { GraphQLList, GraphQLNonNull } }) {
+    let result = replacementType;
+    const wrappers = [];
+    let current = originalType;
+    while (current instanceof GraphQLNonNull || current instanceof GraphQLList) {
+        wrappers.unshift(current.constructor);
+        current = current.ofType;
+    }
+    for (const Wrapper of wrappers) {
+        result = new Wrapper(result);
+    }
+    return result;
+}
+function wrapInputType(originalType, replacementType, { graphql: { GraphQLList, GraphQLNonNull } }) {
+    let result = replacementType;
+    const wrappers = [];
+    let current = originalType;
+    while (current instanceof GraphQLNonNull || current instanceof GraphQLList) {
+        wrappers.unshift(current.constructor);
+        current = current.ofType;
+    }
+    for (const Wrapper of wrappers) {
+        result = new Wrapper(result);
+    }
+    return result;
+}
+function getAttributeFromScope(pgCodec, fieldName, inflection) {
+    if (!pgCodec.attributes) {
+        return undefined;
+    }
+    if (pgCodec.attributes[fieldName]) {
+        return pgCodec.attributes[fieldName];
+    }
+    for (const [attrName, attr] of Object.entries(pgCodec.attributes)) {
+        const graphqlName = inflection.attribute({ attributeName: attrName, codec: pgCodec });
+        if (graphqlName === fieldName) {
+            return attr;
+        }
+    }
+    return undefined;
+}
+export const ReplaceTypesPlugin = {
+    name: 'ReplaceTypesPlugin',
+    version: '0.1.0',
+    schema: {
+        hooks: {
+            'GraphQLObjectType_fields_field': (field, build, ctx) => {
+                const { scope: { pgFieldAttribute, pgCodec, fieldName } } = ctx;
+                if (!pgFieldAttribute || !pgCodec || !fieldName) {
+                    return field;
+                }
+                const attr = getAttributeFromScope(pgCodec, fieldName, build.inflection);
+                if (!attr) {
+                    return field;
+                }
+                const replaceType = attr.extensions?.tags?.replaceType;
+                if (!replaceType) {
+                    return field;
+                }
+                const replacementType = build.getTypeByName(replaceType);
+                if (!replacementType) {
+                    console.warn(`[ReplaceTypesPlugin] Type '${replaceType}' not found. `
+                        + `Cannot replace field '${fieldName}'.`);
+                    return field;
+                }
+                return {
+                    ...field,
+                    type: wrapOutputType(field.type, replacementType, build),
+                };
+            },
+            'GraphQLInputObjectType_fields_field': (field, build, ctx) => {
+                const { scope: { pgCodec, fieldName } } = ctx;
+                if (!pgCodec || !fieldName) {
+                    return field;
+                }
+                const attr = getAttributeFromScope(pgCodec, fieldName, build.inflection);
+                if (!attr) {
+                    return field;
+                }
+                const replaceType = attr.extensions?.tags?.replaceType;
+                if (typeof replaceType !== 'string') {
+                    return field;
+                }
+                const replacementType = build.getTypeByName(replaceType + 'Input')
+                    || build.getTypeByName(replaceType);
+                if (!replacementType) {
+                    console.warn(`[ReplaceTypesPlugin] Type '${replaceType}Input' (or '${replaceType}') not found. `
+                        + `Cannot replace input field '${fieldName}'.`);
+                    return field;
+                }
+                return {
+                    ...field,
+                    type: wrapInputType(field.type, replacementType, build),
+                };
+            },
+        },
+    },
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+	"name": "@haathie/postgraphile-replace-types",
+	"version": "0.1.0",
+	"type": "module",
+	"files": ["lib"],
+	"main": "lib/index.js",
+	"types": "lib/index.d.ts",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/haathie/graphile-tools.git"
+	},
+	"scripts": {
+		"build": "tsc -p tsconfig.json"
+	},
+	"dependencies": {
+		"@haathie/postgraphile-common-utils": "^0.1.2"
+	},
+	"peerDependencies": {
+		"postgraphile": "*"
+	}
+}

package/readme.md

@@ -0,0 +1,49 @@
+# Replace Types
+
+This plugin allows you to replace fields in the GraphQL schema with custom types.
+This is useful for cases where you want to change the behavior of a field without changing the underlying database schema.
+
+## Usage
+
+To use this plugin, you need to install it and then add it to your PostGraphile configuration.
+
+```
+npm i @haathie/postgraphile-replace-types
+```
+
+Add to your preset's plugins:
+```ts
+import { ReplaceTypesPlugin } from '@haathie/postgraphile-replace-types';
+const preset = {
+	...otherStuff,
+	plugins: [
+		...otherPlugins,
+		extendSchema(() => {
+			return {
+				typeDefs: `
+					enum NewTypeName {
+						VALUE1
+					}
+				`,
+				enums: {
+					NewTypeName: {
+						values: {
+							VALUE1: 'VALUE1',
+						}
+					},
+				}
+			}
+		})
+		ReplaceTypesPlugin,
+	],
+}
+```
+
+## Replacing a Field
+
+Add a smart comment tag to the column in the database:
+```sql
+COMMENT ON COLUMN table_name.field_name IS '@replaceType NewTypeName';
+```
+
+For input types, it will first try `NewTypeNameInput`, then fall back to `NewTypeName`.